@ck-ui/component-library 0.2.0 → 1.0.0

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

@@ -0,0 +1,2456 @@
+import { jsx as m, jsxs as E } from "react/jsx-runtime";
+import * as w from "react";
+import { createContext as $e, memo as Ge, useEffect as k, useLayoutEffect as Ye, useState as be, useCallback as Ee, useMemo as b, isValidElement as Xe, cloneElement as ae, useContext as We, useRef as ze } from "react";
+import { CKButton as B } from "../../../CKButton/index.js";
+import { Typography as _ } from "../../../Typography/index.js";
+import { Switch as Qe } from "../../../Switch/index.js";
+import { S as Ke } from "../../../../reset-icon-YxMt3Ozp.js";
+import { S as Je } from "../../../../search-B_cup-NN.js";
+import { ColumnConfig as Ze } from "./ColumnConfig.js";
+import { COLUMN_ITEM_TYPE as ce } from "../../constants.js";
+import '../../../../assets/styles-BTZL03H2.css';/* empty css                          */
+import { g as et } from "../../../../_commonjsHelpers-C6fGbg64.js";
+const Ie = $e({
+  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 ue = (function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+})(), le = function() {
+  return Math.random().toString(36).substring(7).split("").join(".");
+}, de = {
+  INIT: "@@redux/INIT" + le(),
+  REPLACE: "@@redux/REPLACE" + le()
+};
+function tt(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 rt(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 (it(t)) return "error";
+  var r = nt(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 nt(t) {
+  return typeof t.constructor == "function" ? t.constructor.name : null;
+}
+function it(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 = rt(t)), e;
+}
+function we(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(we)(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, o = e, s = [], a = s, c = !1;
+  function d() {
+    a === s && (a = s.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 o;
+  }
+  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), s = null;
+      }
+    };
+  }
+  function g(h) {
+    if (!tt(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, o = i(o, h);
+    } finally {
+      c = !1;
+    }
+    for (var v = s = 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: de.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[ue] = function() {
+      return this;
+    }, h;
+  }
+  return g({
+    type: de.INIT
+  }), n = {
+    dispatch: g,
+    subscribe: p,
+    getState: f,
+    replaceReducer: u
+  }, n[ue] = D, n;
+}
+function l(t, e, ...r) {
+  if (st() && 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 st() {
+  return typeof process < "u" && process.env.NODE_ENV === "production";
+}
+function at(t, e, r) {
+  return e.split(".").reduce(
+    (n, i) => n && n[i] ? n[i] : r || null,
+    t
+  );
+}
+function ct(t, e) {
+  return t.filter(
+    (r) => r !== e
+  );
+}
+function Ce(t) {
+  return typeof t == "object";
+}
+function ut(t, e) {
+  const r = /* @__PURE__ */ new Map(), n = (o) => {
+    r.set(o, r.has(o) ? r.get(o) + 1 : 1);
+  };
+  t.forEach(n), e.forEach(n);
+  const i = [];
+  return r.forEach((o, s) => {
+    o === 1 && i.push(s);
+  }), i;
+}
+function lt(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 ge(t, e) {
+  return {
+    type: ee,
+    payload: {
+      sourceClientOffset: e || null,
+      clientOffset: t || null
+    }
+  };
+}
+const dt = {
+  type: ee,
+  payload: {
+    clientOffset: null,
+    sourceClientOffset: null
+  }
+};
+function gt(t) {
+  return function(r = [], n = {
+    publishSource: !0
+  }) {
+    const { publishSource: i = !0, clientOffset: o, getSourceClientOffset: s } = n, a = t.getMonitor(), c = t.getRegistry();
+    t.dispatch(ge(o)), ft(r, a, c);
+    const d = mt(r, a);
+    if (d == null) {
+      t.dispatch(dt);
+      return;
+    }
+    let f = null;
+    if (o) {
+      if (!s)
+        throw new Error("getSourceClientOffset must be defined");
+      ht(s), f = s(d);
+    }
+    t.dispatch(ge(o, f));
+    const g = c.getSource(d).beginDrag(a, d);
+    if (g == null)
+      return;
+    pt(g), c.pinSource(d);
+    const u = c.getSourceType(d);
+    return {
+      type: A,
+      payload: {
+        itemType: u,
+        item: g,
+        sourceId: d,
+        clientOffset: o || null,
+        sourceClientOffset: f || null,
+        isSourcePublic: !!i
+      }
+    };
+  };
+}
+function ft(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 ht(t) {
+  l(typeof t == "function", "When clientOffset is provided, getSourceClientOffset must be a function.");
+}
+function pt(t) {
+  l(Ce(t), "Item must be an object.");
+}
+function mt(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 vt(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function Dt(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) {
+      vt(t, i, r[i]);
+    });
+  }
+  return t;
+}
+function yt(t) {
+  return function(r = {}) {
+    const n = t.getMonitor(), i = t.getRegistry();
+    St(n), bt(n).forEach((s, a) => {
+      const c = Ot(s, a, i, n), d = {
+        type: j,
+        payload: {
+          dropResult: Dt({}, r, c)
+        }
+      };
+      t.dispatch(d);
+    });
+  };
+}
+function St(t) {
+  l(t.isDragging(), "Cannot call drop while not dragging."), l(!t.didDrop(), "Cannot call drop twice during one drag operation.");
+}
+function Ot(t, e, r, n) {
+  const i = r.getTarget(t);
+  let o = i ? i.drop(n, t) : void 0;
+  return Tt(o), typeof o > "u" && (o = e === 0 ? {} : n.getDropResult()), o;
+}
+function Tt(t) {
+  l(typeof t > "u" || Ce(t), "Drop result must either be an object or undefined.");
+}
+function bt(t) {
+  const e = t.getTargetIds().filter(t.canDropOnTarget, t);
+  return e.reverse(), e;
+}
+function Et(t) {
+  return function() {
+    const r = t.getMonitor(), n = t.getRegistry();
+    It(r);
+    const i = r.getSourceId();
+    return i != null && (n.getSource(i, !0).endDrag(r, i), n.unpinSource()), {
+      type: U
+    };
+  };
+}
+function It(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 wt(t) {
+  return function(r, { clientOffset: n } = {}) {
+    Ct(r);
+    const i = r.slice(0), o = t.getMonitor(), s = t.getRegistry(), a = o.getItemType();
+    return Pt(i, s, a), Nt(i, o, s), xt(i, o, s), {
+      type: H,
+      payload: {
+        targetIds: i,
+        clientOffset: n || null
+      }
+    };
+  };
+}
+function Ct(t) {
+  l(Array.isArray(t), "Expected targetIds to be an array.");
+}
+function Nt(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 o = r.getTarget(i);
+    l(o, "Expected targetIds to be registered.");
+  }
+}
+function Pt(t, e, r) {
+  for (let n = t.length - 1; n >= 0; n--) {
+    const i = t[n], o = e.getTargetType(i);
+    z(o, r) || t.splice(n, 1);
+  }
+}
+function xt(t, e, r) {
+  t.forEach(function(n) {
+    r.getTarget(n).hover(e, n);
+  });
+}
+function Rt(t) {
+  return function() {
+    if (t.getMonitor().isDragging())
+      return {
+        type: te
+      };
+  };
+}
+function Mt(t) {
+  return {
+    beginDrag: gt(t),
+    publishDragSource: Rt(t),
+    hover: wt(t),
+    drop: yt(t),
+    endDrag: Et(t)
+  };
+}
+class _t {
+  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(o) {
+      return (...s) => {
+        const a = o.apply(e, s);
+        typeof a < "u" && r(a);
+      };
+    }
+    const i = Mt(this);
+    return Object.keys(i).reduce((o, s) => {
+      const a = i[s];
+      return o[s] = n(a), o;
+    }, {});
+  }
+  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 Lt(t, e) {
+  return {
+    x: t.x + e.x,
+    y: t.y + e.y
+  };
+}
+function Ne(t, e) {
+  return {
+    x: t.x - e.x,
+    y: t.y - e.y
+  };
+}
+function kt(t) {
+  const { clientOffset: e, initialClientOffset: r, initialSourceClientOffset: n } = t;
+  return !e || !r || !n ? null : Ne(Lt(e, n), r);
+}
+function At(t) {
+  const { clientOffset: e, initialClientOffset: r } = t;
+  return !e || !r ? null : Ne(e, r);
+}
+const R = [], re = [];
+R.__IS_NONE__ = !0;
+re.__IS_ALL__ = !0;
+function Ht(t, e) {
+  return t === R ? !1 : t === re || typeof e > "u" ? !0 : lt(e, t).length > 0;
+}
+class jt {
+  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 o = () => {
+      const s = this.store.getState(), a = s.stateId;
+      try {
+        a === i || a === i + 1 && !Ht(s.dirtyHandlerIds, n) || e();
+      } finally {
+        i = a;
+      }
+    };
+    return this.store.subscribe(o);
+  }
+  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), o = this.getItemType();
+    if (o && !z(i, o))
+      return !1;
+    const s = this.getTargetIds();
+    if (!s.length)
+      return !1;
+    const a = s.indexOf(e);
+    return n ? a === s.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 kt(this.store.getState().dragOffset);
+  }
+  getDifferenceFromInitialOffset() {
+    return At(this.store.getState().dragOffset);
+  }
+  constructor(e, r) {
+    this.store = e, this.registry = r;
+  }
+}
+const fe = typeof global < "u" ? global : self, Pe = fe.MutationObserver || fe.WebKitMutationObserver;
+function xe(t) {
+  return function() {
+    const r = setTimeout(i, 0), n = setInterval(i, 50);
+    function i() {
+      clearTimeout(r), clearInterval(n), t();
+    }
+  };
+}
+function Ut(t) {
+  let e = 1;
+  const r = new Pe(t), n = document.createTextNode("");
+  return r.observe(n, {
+    characterData: !0
+  }), function() {
+    e = -e, n.data = e;
+  };
+}
+const Vt = typeof Pe == "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
+  Ut
+) : (
+  // 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
+  xe
+);
+class Ft {
+  // 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 = Vt(this.flush), this.requestErrorThrow = xe(() => {
+      if (this.pendingErrors.length)
+        throw this.pendingErrors.shift();
+    });
+  }
+}
+class Bt {
+  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 qt {
+  create(e) {
+    const r = this.freeTasks, n = r.length ? r.pop() : new Bt(
+      this.onError,
+      (i) => r[r.length] = i
+    );
+    return n.task = e, n;
+  }
+  constructor(e) {
+    this.onError = e, this.freeTasks = [];
+  }
+}
+const Re = new Ft(), $t = new qt(Re.registerPendingError);
+function Gt(t) {
+  Re.enqueueTask($t.create(t));
+}
+const ne = "dnd-core/ADD_SOURCE", ie = "dnd-core/ADD_TARGET", oe = "dnd-core/REMOVE_SOURCE", V = "dnd-core/REMOVE_TARGET";
+function Yt(t) {
+  return {
+    type: ne,
+    payload: {
+      sourceId: t
+    }
+  };
+}
+function Xt(t) {
+  return {
+    type: ie,
+    payload: {
+      targetId: t
+    }
+  };
+}
+function Wt(t) {
+  return {
+    type: oe,
+    payload: {
+      sourceId: t
+    }
+  };
+}
+function zt(t) {
+  return {
+    type: V,
+    payload: {
+      targetId: t
+    }
+  };
+}
+function Qt(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 Kt(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 Jt = 0;
+function Zt() {
+  return Jt++;
+}
+function er(t) {
+  const e = Zt().toString();
+  switch (t) {
+    case T.SOURCE:
+      return `S${e}`;
+    case T.TARGET:
+      return `T${e}`;
+    default:
+      throw new Error(`Unknown Handler Role: ${t}`);
+  }
+}
+function he(t) {
+  switch (t[0]) {
+    case "S":
+      return T.SOURCE;
+    case "T":
+      return T.TARGET;
+    default:
+      throw new Error(`Cannot parse handler ID: ${t}`);
+  }
+}
+function pe(t, e) {
+  const r = t.entries();
+  let n = !1;
+  do {
+    const { done: i, value: [, o] } = r.next();
+    if (o === e)
+      return !0;
+    n = !!i;
+  } while (!n);
+  return !1;
+}
+class tr {
+  addSource(e, r) {
+    Q(e), Qt(r);
+    const n = this.addHandler(T.SOURCE, e, r);
+    return this.store.dispatch(Yt(n)), n;
+  }
+  addTarget(e, r) {
+    Q(e, !0), Kt(r);
+    const n = this.addHandler(T.TARGET, e, r);
+    return this.store.dispatch(Xt(n)), n;
+  }
+  containsHandler(e) {
+    return pe(this.dragSources, e) || pe(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 he(e) === T.SOURCE;
+  }
+  isTargetId(e) {
+    return he(e) === T.TARGET;
+  }
+  removeSource(e) {
+    l(this.getSource(e), "Expected an existing source."), this.store.dispatch(Wt(e)), Gt(() => {
+      this.dragSources.delete(e), this.types.delete(e);
+    });
+  }
+  removeTarget(e) {
+    l(this.getTarget(e), "Expected an existing target."), this.store.dispatch(zt(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 = er(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 rr = (t, e) => t === e;
+function nr(t, e) {
+  return !t && !e ? !0 : !t || !e ? !1 : t.x === e.x && t.y === e.y;
+}
+function ir(t, e, r = rr) {
+  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 oe:
+      return R;
+    case A:
+    case te:
+    case U:
+    case j:
+    default:
+      return re;
+  }
+  const { targetIds: r = [], prevTargetIds: n = [] } = e.payload, i = ut(r, n);
+  if (!(i.length > 0 || !ir(r, n)))
+    return R;
+  const s = n[n.length - 1], a = r[r.length - 1];
+  return s !== a && (s && i.push(s), a && i.push(a)), i;
+}
+function sr(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function ar(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) {
+      sr(t, i, r[i]);
+    });
+  }
+  return t;
+}
+const me = {
+  initialSourceClientOffset: null,
+  initialClientOffset: null,
+  clientOffset: null
+};
+function cr(t = me, 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 nr(t.clientOffset, r.clientOffset) ? t : ar({}, t, {
+        clientOffset: r.clientOffset
+      });
+    case U:
+    case j:
+      return me;
+    default:
+      return t;
+  }
+}
+function ur(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) {
+      ur(t, i, r[i]);
+    });
+  }
+  return t;
+}
+const lr = {
+  itemType: null,
+  item: null,
+  sourceId: null,
+  targetIds: [],
+  dropResult: null,
+  didDrop: !1,
+  isSourcePublic: null
+};
+function dr(t = lr, 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: ct(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 gr(t = 0, e) {
+  switch (e.type) {
+    case ne:
+    case ie:
+      return t + 1;
+    case oe:
+    case V:
+      return t - 1;
+    default:
+      return t;
+  }
+}
+function fr(t = 0) {
+  return t + 1;
+}
+function hr(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function pr(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) {
+      hr(t, i, r[i]);
+    });
+  }
+  return t;
+}
+function mr(t = {}, e) {
+  return {
+    dirtyHandlerIds: or(t.dirtyHandlerIds, {
+      type: e.type,
+      payload: pr({}, e.payload, {
+        prevTargetIds: at(t, "dragOperation.targetIds", [])
+      })
+    }),
+    dragOffset: cr(t.dragOffset, e),
+    refCount: gr(t.refCount, e),
+    dragOperation: dr(t.dragOperation, e),
+    stateId: fr(t.stateId)
+  };
+}
+function vr(t, e = void 0, r = {}, n = !1) {
+  const i = Dr(n), o = new jt(i, new tr(i)), s = new _t(i, o), a = t(s, e, r);
+  return s.receiveBackend(a), s;
+}
+function Dr(t) {
+  const e = typeof window < "u" && window.__REDUX_DEVTOOLS_EXTENSION__;
+  return we(mr, t && e && e({
+    name: "dnd-core",
+    instanceId: "dnd-core"
+  }));
+}
+function yr(t, e) {
+  if (t == null) return {};
+  var r = Sr(t, e), n, i;
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(t);
+    for (i = 0; i < o.length; i++)
+      n = o[i], !(e.indexOf(n) >= 0) && Object.prototype.propertyIsEnumerable.call(t, n) && (r[n] = t[n]);
+  }
+  return r;
+}
+function Sr(t, e) {
+  if (t == null) return {};
+  var r = {}, n = Object.keys(t), i, o;
+  for (o = 0; o < n.length; o++)
+    i = n[o], !(e.indexOf(i) >= 0) && (r[i] = t[i]);
+  return r;
+}
+let ve = 0;
+const L = /* @__PURE__ */ Symbol.for("__REACT_DND_CONTEXT_INSTANCE__");
+var Or = /* @__PURE__ */ Ge(function(e) {
+  var { children: r } = e, n = yr(e, [
+    "children"
+  ]);
+  const [i, o] = Tr(n);
+  return k(() => {
+    if (o) {
+      const s = Me();
+      return ++ve, () => {
+        --ve === 0 && (s[L] = null);
+      };
+    }
+  }, []), /* @__PURE__ */ m(Ie.Provider, {
+    value: i,
+    children: r
+  });
+});
+function Tr(t) {
+  if ("manager" in t)
+    return [
+      {
+        dragDropManager: t.manager
+      },
+      !1
+    ];
+  const e = br(t.backend, t.context, t.options, t.debugMode), r = !t.context;
+  return [
+    e,
+    r
+  ];
+}
+function br(t, e = Me(), r, n) {
+  const i = e;
+  return i[L] || (i[L] = {
+    dragDropManager: vr(t, e, r, n)
+  }), i[L];
+}
+function Me() {
+  return typeof global < "u" ? global : window;
+}
+var q, De;
+function Er() {
+  return De || (De = 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, o;
+      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 (o = Object.keys(e), n = o.length, n !== Object.keys(r).length) return !1;
+      for (i = n; i-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(r, o[i])) return !1;
+      for (i = n; i-- !== 0; ) {
+        var s = o[i];
+        if (!t(e[s], r[s])) return !1;
+      }
+      return !0;
+    }
+    return e !== e && r !== r;
+  }), q;
+}
+var Ir = Er();
+const wr = /* @__PURE__ */ et(Ir), C = typeof window < "u" ? Ye : k;
+function Cr(t, e, r) {
+  const [n, i] = be(
+    () => e(t)
+  ), o = Ee(() => {
+    const s = e(t);
+    wr(n, s) || (i(s), r && r());
+  }, [
+    n,
+    t,
+    r
+  ]);
+  return C(o), [
+    n,
+    o
+  ];
+}
+function Nr(t, e, r) {
+  const [n, i] = Cr(t, e, r);
+  return C(function() {
+    const s = t.getHandlerId();
+    if (s != null)
+      return t.subscribeToStateChange(i, {
+        handlerIds: [
+          s
+        ]
+      });
+  }, [
+    t,
+    i
+  ]), n;
+}
+function _e(t, e, r) {
+  return Nr(
+    e,
+    t || (() => ({})),
+    () => r.reconnect()
+  );
+}
+function Le(t, e) {
+  const r = [];
+  return typeof t != "function" && r.push(t), b(() => typeof t == "function" ? t() : t, r);
+}
+function Pr(t) {
+  return b(
+    () => t.hooks.dragSource(),
+    [
+      t
+    ]
+  );
+}
+function xr(t) {
+  return b(
+    () => t.hooks.dragPreview(),
+    [
+      t
+    ]
+  );
+}
+let $ = !1, G = !1;
+class Rr {
+  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 Mr {
+  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 _r(t, e, r) {
+  const n = r.getRegistry(), i = n.addTarget(t, e);
+  return [
+    i,
+    () => n.removeTarget(i)
+  ];
+}
+function Lr(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 o = Object.keys(t), s = Object.keys(e);
+  if (o.length !== s.length)
+    return !1;
+  const a = Object.prototype.hasOwnProperty.bind(e);
+  for (let c = 0; c < o.length; c++) {
+    const d = o[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 kr(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 Ar(t) {
+  return (e = null, r = null) => {
+    if (!Xe(e)) {
+      const o = e;
+      return t(o, r), o;
+    }
+    const n = e;
+    return kr(n), Hr(n, r ? (o) => t(o, r) : t);
+  };
+}
+function ke(t) {
+  const e = {};
+  return Object.keys(t).forEach((r) => {
+    const n = t[r];
+    if (r.endsWith("Ref"))
+      e[r] = t[r];
+    else {
+      const i = Ar(n);
+      e[r] = () => i;
+    }
+  }), e;
+}
+function ye(t, e) {
+  typeof t == "function" ? t(e) : t.current = e;
+}
+function Hr(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) => {
+      ye(r, n), ye(e, n);
+    }
+  }) : ae(t, {
+    ref: e
+  });
+}
+class jr {
+  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 = ke({
+      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 Ur {
+  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 = ke({
+      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 } = We(Ie);
+  return l(t != null, "Expected drag drop context"), t;
+}
+function Vr(t, e) {
+  const r = x(), n = b(
+    () => new jr(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 Fr() {
+  const t = x();
+  return b(
+    () => new Rr(t),
+    [
+      t
+    ]
+  );
+}
+class Br {
+  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: o } = n;
+    return o ? o(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 qr(t, e, r) {
+  const n = b(
+    () => new Br(t, e, r),
+    [
+      e,
+      r
+    ]
+  );
+  return k(() => {
+    n.spec = t;
+  }, [
+    t
+  ]), n;
+}
+function $r(t) {
+  return b(() => {
+    const e = t.type;
+    return l(e != null, "spec.type must be defined"), e;
+  }, [
+    t
+  ]);
+}
+function Gr(t, e, r) {
+  const n = x(), i = qr(t, e, r), o = $r(t);
+  C(function() {
+    if (o != null) {
+      const [a, c] = Lr(o, i, n);
+      return e.receiveHandlerId(a), r.receiveHandlerId(a), c;
+    }
+  }, [
+    n,
+    e,
+    r,
+    i,
+    o
+  ]);
+}
+function Yr(t, e) {
+  const r = Le(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 = Fr(), i = Vr(r.options, r.previewOptions);
+  return Gr(r, n, i), [
+    _e(r.collect, n, i),
+    Pr(i),
+    xr(i)
+  ];
+}
+function Xr(t) {
+  return b(
+    () => t.hooks.dropTarget(),
+    [
+      t
+    ]
+  );
+}
+function Wr(t) {
+  const e = x(), r = b(
+    () => new Ur(e.getBackend()),
+    [
+      e
+    ]
+  );
+  return C(() => (r.dropTargetOptions = t || null, r.reconnect(), () => r.disconnectDropTarget()), [
+    t
+  ]), r;
+}
+function zr() {
+  const t = x();
+  return b(
+    () => new Mr(t),
+    [
+      t
+    ]
+  );
+}
+function Qr(t) {
+  const { accept: e } = t;
+  return b(() => (l(t.accept != null, "accept must be defined"), Array.isArray(e) ? e : [
+    e
+  ]), [
+    e
+  ]);
+}
+class Kr {
+  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 Jr(t, e) {
+  const r = b(
+    () => new Kr(t, e),
+    [
+      e
+    ]
+  );
+  return k(() => {
+    r.spec = t;
+  }, [
+    t
+  ]), r;
+}
+function Zr(t, e, r) {
+  const n = x(), i = Jr(t, e), o = Qr(t);
+  C(function() {
+    const [a, c] = _r(o, i, n);
+    return e.receiveHandlerId(a), r.receiveHandlerId(a), c;
+  }, [
+    n,
+    e,
+    i,
+    r,
+    o.map(
+      (s) => s.toString()
+    ).join("|")
+  ]);
+}
+function en(t, e) {
+  const r = Le(t), n = zr(), i = Wr(r.options);
+  return Zr(r, n, i), [
+    _e(r.collect, n, i),
+    Xr(i)
+  ];
+}
+function Ae(t) {
+  let e = null;
+  return () => (e == null && (e = t()), e);
+}
+function tn(t, e) {
+  return t.filter(
+    (r) => r !== e
+  );
+}
+function rn(t, e) {
+  const r = /* @__PURE__ */ new Set(), n = (o) => r.add(o);
+  t.forEach(n), e.forEach(n);
+  const i = [];
+  return r.forEach(
+    (o) => i.push(o)
+  ), i;
+}
+class nn {
+  enter(e) {
+    const r = this.entered.length, n = (i) => this.isNodeInDocument(i) && (!i.contains || i.contains(e));
+    return this.entered = rn(this.entered.filter(n), [
+      e
+    ]), r === 0 && this.entered.length > 0;
+  }
+  leave(e) {
+    const r = this.entered.length;
+    return this.entered = tn(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 He = "__NATIVE_FILE__", je = "__NATIVE_URL__", Ue = "__NATIVE_TEXT__", Ve = "__NATIVE_HTML__", Se = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  FILE: He,
+  HTML: Ve,
+  TEXT: Ue,
+  URL: je
+}, Symbol.toStringTag, { value: "Module" }));
+function X(t, e, r) {
+  const n = e.reduce(
+    (i, o) => i || t.getData(o),
+    ""
+  );
+  return n ?? r;
+}
+const Z = {
+  [He]: {
+    exposeProperties: {
+      files: (t) => Array.prototype.slice.call(t.files),
+      items: (t) => t.items,
+      dataTransfer: (t) => t
+    },
+    matchesTypes: [
+      "Files"
+    ]
+  },
+  [Ve]: {
+    exposeProperties: {
+      html: (t, e) => X(t, e, ""),
+      dataTransfer: (t) => t
+    },
+    matchesTypes: [
+      "Html",
+      "text/html"
+    ]
+  },
+  [je]: {
+    exposeProperties: {
+      urls: (t, e) => X(t, e, "").split(`
+`),
+      dataTransfer: (t) => t
+    },
+    matchesTypes: [
+      "Url",
+      "text/uri-list"
+    ]
+  },
+  [Ue]: {
+    exposeProperties: {
+      text: (t, e) => X(t, e, ""),
+      dataTransfer: (t) => t
+    },
+    matchesTypes: [
+      "Text",
+      "text/plain"
+    ]
+  }
+};
+function sn(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 an = Ae(
+  () => /firefox/i.test(navigator.userAgent)
+), Fe = Ae(
+  () => !!window.safari
+);
+class Oe {
+  interpolate(e) {
+    const { xs: r, ys: n, c1s: i, c2s: o, c3s: s } = this;
+    let a = r.length - 1;
+    if (e === r[a])
+      return n[a];
+    let c = 0, d = s.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 + o[a] * g + s[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 o = [], s = [];
+    let a, c;
+    for (let u = 0; u < n - 1; u++)
+      a = e[u + 1] - e[u], c = r[u + 1] - r[u], o.push(a), s.push(c / a);
+    const d = [
+      s[0]
+    ];
+    for (let u = 0; u < o.length - 1; u++) {
+      const D = s[u], h = s[u + 1];
+      if (D * h <= 0)
+        d.push(0);
+      else {
+        a = o[u];
+        const v = o[u + 1], y = a + v;
+        d.push(3 * y / ((y + v) / D + (y + a) / h));
+      }
+    }
+    d.push(s[s.length - 1]);
+    const f = [], p = [];
+    let g;
+    for (let u = 0; u < d.length - 1; u++) {
+      g = s[u];
+      const D = d[u], h = 1 / o[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 cn = 1;
+function Be(t) {
+  const e = t.nodeType === cn ? 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 un(t) {
+  var e;
+  return t.nodeName === "IMG" && (an() || !(!((e = document.documentElement) === null || e === void 0) && e.contains(t)));
+}
+function ln(t, e, r, n) {
+  let i = t ? e.width : r, o = t ? e.height : n;
+  return Fe() && t && (o /= window.devicePixelRatio, i /= window.devicePixelRatio), {
+    dragPreviewWidth: i,
+    dragPreviewHeight: o
+  };
+}
+function dn(t, e, r, n, i) {
+  const o = un(e), a = Be(o ? 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 } = ln(o, e, d, f), h = () => {
+    let se = new Oe([
+      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 Fe() && o && (se += (window.devicePixelRatio - 1) * D), se;
+  }, v = () => new Oe([
+    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 gn {
+  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 fn(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function Te(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) {
+      fn(t, i, r[i]);
+    });
+  }
+  return t;
+}
+class hn {
+  /**
+  * 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 = (s) => this.handleDragStart(s, e), o = (s) => this.handleSelectStart(s);
+    return r.setAttribute("draggable", "true"), r.addEventListener("dragstart", i), r.addEventListener("selectstart", o), () => {
+      this.sourceNodes.delete(e), this.sourceNodeOptions.delete(e), r.removeEventListener("dragstart", i), r.removeEventListener("selectstart", o), r.setAttribute("draggable", "false");
+    };
+  }
+  connectDropTarget(e, r) {
+    const n = (s) => this.handleDragEnter(s, e), i = (s) => this.handleDragOver(s, e), o = (s) => this.handleDrop(s, e);
+    return r.addEventListener("dragenter", n), r.addEventListener("dragover", i), r.addEventListener("drop", o), () => {
+      r.removeEventListener("dragenter", n), r.removeEventListener("dragover", i), r.removeEventListener("drop", o);
+    };
+  }
+  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 Te({
+      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 Te({
+      anchorX: 0.5,
+      anchorY: 0.5,
+      captureDraggingState: !1
+    }, r || {});
+  }
+  isDraggingNativeItem() {
+    const e = this.monitor.getItemType();
+    return Object.keys(Se).some(
+      (r) => Se[r] === e
+    );
+  }
+  beginDragNativeItem(e, r) {
+    this.clearCurrentDragSourceNode(), this.currentNativeSource = sn(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 o = this.sourceNodes.get(i);
+      return o && Be(o) || 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: o } = this;
+      this.dragStartSourceIds = null;
+      const s = M(i);
+      this.monitor.isDragging() && (this.actions.endDrag(), this.cancelHover()), this.actions.beginDrag(o || [], {
+        publishSource: !1,
+        getSourceClientOffset: this.getSourceClientOffset,
+        clientOffset: s
+      });
+      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 = dn(p, g, s, {
+              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 o;
+        (o = this.currentNativeSource) === null || o === void 0 || o.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: o } = this;
+      if (this.dragEnterTargetIds = [], !this.monitor.isDragging())
+        return;
+      this.altKeyPressed = i.altKey, o.length > 0 && this.actions.hover(o, {
+        clientOffset: M(i)
+      }), o.some(
+        (a) => this.monitor.canDropOnTarget(a)
+      ) && (i.preventDefault(), i.dataTransfer && (i.dataTransfer.dropEffect = this.getCurrentDropEffect()));
+    }, this.handleTopDragOverCapture = (i) => {
+      if (this.dragOverTargetIds = [], this.isDraggingNativeItem()) {
+        var o;
+        (o = this.currentNativeSource) === null || o === void 0 || o.loadDataTransfer(i.dataTransfer);
+      }
+    }, this.handleTopDragOver = (i) => {
+      const { dragOverTargetIds: o } = 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(o), (o || []).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 o;
+        i.preventDefault(), (o = this.currentNativeSource) === null || o === void 0 || o.loadDataTransfer(i.dataTransfer);
+      } else W(i.dataTransfer) && i.preventDefault();
+      this.enterLeaveCounter.reset();
+    }, this.handleTopDrop = (i) => {
+      const { dropTargetIds: o } = this;
+      this.dropTargetIds = [], this.actions.hover(o, {
+        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 o = i.target;
+      typeof o.dragDrop == "function" && (o.tagName === "INPUT" || o.tagName === "SELECT" || o.tagName === "TEXTAREA" || o.isContentEditable || (i.preventDefault(), o.dragDrop()));
+    }, this.options = new gn(r, n), this.actions = e.getActions(), this.monitor = e.getMonitor(), this.registry = e.getRegistry(), this.enterLeaveCounter = new nn(this.isNodeInDocument);
+  }
+}
+const pn = function(e, r, n) {
+  return new hn(e, r, n);
+}, mn = (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 vn({
+  column: t,
+  index: e,
+  moveListItem: r,
+  visibility: n,
+  onToggleVisibility: i
+}) {
+  const o = t.isDraggable !== !1, s = t.toogleVisibility !== !1 && t.toggleVisibility !== !1, a = ze(null), [, c] = en({
+    accept: ce,
+    hover(p) {
+      o && p.index !== e && (r(p.index, e), p.index = e);
+    }
+  }), [{ isDragging: d }, f] = Yr({
+    type: ce,
+    item: { index: e },
+    canDrag: o,
+    collect: (p) => ({
+      isDragging: p.isDragging()
+    })
+  });
+  return o ? f(c(a)) : c(a), /* @__PURE__ */ E(
+    "div",
+    {
+      ref: a,
+      className: "ckds-dragable-list-item",
+      style: { opacity: d ? 0.5 : 1 },
+      children: [
+        /* @__PURE__ */ m(
+          "div",
+          {
+            className: "ckds-drag-handle",
+            style: { cursor: o ? "grab" : "not-allowed", opacity: o ? 1 : 0.3 },
+            children: /* @__PURE__ */ m(mn, { style: { color: "var(--ckcl-black-500, #2b2b2b)" } })
+          }
+        ),
+        /* @__PURE__ */ m(_, { variant: "body-sm", className: "ckds-dragable-list-item-label", children: t.header }),
+        /* @__PURE__ */ m(
+          Qe,
+          {
+            checked: n[t.accessorKey] !== !1,
+            onChange: () => i(t.accessorKey),
+            disabled: !s,
+            className: "ckds-dragable-list-item-toggle"
+          }
+        )
+      ]
+    }
+  );
+}
+function Pn({
+  draftConfig: t,
+  setDraftConfig: e,
+  moveDraftColumn: r,
+  handleApplyPref: n,
+  setModalOpen: i,
+  handleResetToDefault: o,
+  isDefault: s,
+  isConfigChanged: a
+}) {
+  const [c, d] = be(""), f = Ee(
+    (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(Or, { backend: pn, children: [
+    /* @__PURE__ */ E("div", { className: "ckds-column-manager-wrapper", children: [
+      /* @__PURE__ */ E("div", { style: { display: "flex", alignItems: "center", justifyContent: "space-between" }, children: [
+        /* @__PURE__ */ m(_, { variant: "body-lg", weight: "semibold", children: "Column Manager" }),
+        /* @__PURE__ */ m(
+          B,
+          {
+            onClick: o,
+            variant: "hyperlink",
+            disabled: s,
+            icons: { left: /* @__PURE__ */ m(Ke, {}) },
+            label: "Reset to default"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ E("div", { style: { display: "flex", marginTop: "24px" }, children: [
+        /* @__PURE__ */ m(Ze, { draftConfig: t, setDraftConfig: e }),
+        /* @__PURE__ */ E("div", { style: { flex: 1, marginLeft: "28px" }, children: [
+          /* @__PURE__ */ m(_, { variant: "body-sm", weight: "medium", children: "Visible Columns" }),
+          /* @__PURE__ */ m(_, { variant: "body-xs", color: "secondary", children: "Toggle columns on/off and drag to reorder" }),
+          /* @__PURE__ */ m(
+            "div",
+            {
+              className: p.length > 9 ? "ckds-search-border-bottom" : "",
+              style: { paddingBottom: "12px", marginTop: "16px" },
+              children: /* @__PURE__ */ E("div", { className: "ckds-search-input-wrapper", children: [
+                /* @__PURE__ */ m(Je, {}),
+                /* @__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", { style: { display: "flex", flex: 1, alignItems: "center", justifyContent: "center", height: "318px" }, children: /* @__PURE__ */ m("p", { className: "text-sm", style: { color: "var(--ckcl-black-400, #737373)" }, children: "No columns found" }) }) : /* @__PURE__ */ m("div", { className: "ckds-dragable-list ckds-custom-scrollbar", children: p.map((g, u) => /* @__PURE__ */ m(
+            vn,
+            {
+              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 {
+  Pn as default
+};