@caspeco/casper-ui-library 8.2.2 → 8.4.0

package/dist/node_modules/@dnd-kit/geometry/dist/index.js

@@ -0,0 +1,200 @@
+import { ValueHistory as W, derived as S } from "../../state/dist/index.js";
+import { batch as G } from "../../../@preact/signals-core/dist/signals-core.module.js";
+var N = Object.create, z = Object.defineProperty, T = Object.getOwnPropertyDescriptor, R = Object.getOwnPropertySymbols, B = Object.prototype.hasOwnProperty, J = Object.prototype.propertyIsEnumerable, I = (r, t) => (t = Symbol[r]) ? t : /* @__PURE__ */ Symbol.for("Symbol." + r), p = (r) => {
+  throw TypeError(r);
+}, A = Math.pow, g = (r, t, e) => t in r ? z(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, K = (r, t) => {
+  for (var e in t || (t = {}))
+    B.call(t, e) && g(r, e, t[e]);
+  if (R)
+    for (var e of R(t))
+      J.call(t, e) && g(r, e, t[e]);
+  return r;
+}, L = (r) => {
+  var t;
+  return [, , , N((t = r?.[I("metadata")]) != null ? t : null)];
+}, k = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], C = (r) => r !== void 0 && typeof r != "function" ? p("Function expected") : r, Q = (r, t, e, i, n) => ({ kind: k[r], name: t, metadata: i, addInitializer: (o) => e._ ? p("Already initialized") : n.push(C(o || null)) }), U = (r, t) => g(t, I("metadata"), r[3]), X = (r, t, e, i) => {
+  for (var n = 0, o = r[t >> 1], s = o && o.length; n < s; n++) o[n].call(e);
+  return i;
+}, D = (r, t, e, i, n, o) => {
+  for (var s, c, a, u, M = t & 7, j = !1, F = !1, O = 2, P = k[M + 5], H = r[O] || (r[O] = []), d = (n = n.prototype, T(n, e)), v = i.length - 1; v >= 0; v--)
+    a = Q(M, e, c = {}, r[3], H), a.static = j, a.private = F, u = a.access = { has: (x) => e in x }, u.get = (x) => x[e], s = (0, i[v])(d[P], a), c._ = 1, C(s) && (d[P] = s);
+  return d && z(n, e, d), n;
+}, E = (r, t, e) => t.has(r) || p("Cannot " + e), Y = (r, t, e) => (E(r, t, "read from private field"), t.get(r)), Z = (r, t, e) => t.has(r) ? p("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(r) : t.set(r, e), $ = (r, t, e, i) => (E(r, t, "write to private field"), t.set(r, e), e), l = class _ {
+  /**
+   * @param {number} Coordinate of the point on the horizontal axis
+   * @param {number} Coordinate of the point on the vertical axis
+   */
+  constructor(t, e) {
+    this.x = t, this.y = e;
+  }
+  /**
+   * Returns the delta between this point and another point.
+   *
+   * @param {Point} a - A point
+   * @param {Point} b - Another point
+   */
+  static delta(t, e) {
+    return new _(t.x - e.x, t.y - e.y);
+  }
+  /**
+   * Returns the distance (hypotenuse) between this point and another point.
+   *
+   * @param {Point} a - A point
+   * @param {Point} b - Another point
+   */
+  static distance(t, e) {
+    return Math.hypot(t.x - e.x, t.y - e.y);
+  }
+  /**
+   * Returns true if both points are equal.
+   *
+   * @param {Point} a - A point
+   * @param {Point} b - Another point
+   */
+  static equals(t, e) {
+    return t.x === e.x && t.y === e.y;
+  }
+  static from({ x: t, y: e }) {
+    return new _(t, e);
+  }
+}, nt = class h {
+  constructor(t, e, i, n) {
+    this.left = t, this.top = e, this.width = i, this.height = n, this.scale = {
+      x: 1,
+      y: 1
+    };
+  }
+  get inverseScale() {
+    return {
+      x: 1 / this.scale.x,
+      y: 1 / this.scale.y
+    };
+  }
+  translate(t, e) {
+    const { top: i, left: n, width: o, height: s, scale: c } = this, a = new h(n + t, i + e, o, s);
+    return a.scale = K({}, c), a;
+  }
+  get boundingRectangle() {
+    const { width: t, height: e, left: i, top: n, right: o, bottom: s } = this;
+    return { width: t, height: e, left: i, top: n, right: o, bottom: s };
+  }
+  get center() {
+    const { left: t, top: e, right: i, bottom: n } = this;
+    return new l((t + i) / 2, (e + n) / 2);
+  }
+  get area() {
+    const { width: t, height: e } = this;
+    return t * e;
+  }
+  equals(t) {
+    if (!(t instanceof h))
+      return !1;
+    const { left: e, top: i, width: n, height: o } = this;
+    return e === t.left && i === t.top && n === t.width && o === t.height;
+  }
+  containsPoint(t) {
+    const { top: e, left: i, bottom: n, right: o } = this;
+    return e <= t.y && t.y <= n && i <= t.x && t.x <= o;
+  }
+  intersectionArea(t) {
+    return t instanceof h ? tt(this, t) : 0;
+  }
+  intersectionRatio(t) {
+    const { area: e } = this, i = this.intersectionArea(t);
+    return i / (t.area + e - i);
+  }
+  get bottom() {
+    const { top: t, height: e } = this;
+    return t + e;
+  }
+  get right() {
+    const { left: t, width: e } = this;
+    return t + e;
+  }
+  get aspectRatio() {
+    const { width: t, height: e } = this;
+    return t / e;
+  }
+  get corners() {
+    return [
+      { x: this.left, y: this.top },
+      { x: this.right, y: this.top },
+      { x: this.left, y: this.bottom },
+      { x: this.right, y: this.bottom }
+    ];
+  }
+  static from({ top: t, left: e, width: i, height: n }) {
+    return new h(e, t, i, n);
+  }
+  static delta(t, e, i = { x: "center", y: "center" }) {
+    const n = (o, s) => {
+      const c = i[s], a = s === "x" ? o.left : o.top, u = s === "x" ? o.width : o.height;
+      return c == "start" ? a : c == "end" ? a + u : a + u / 2;
+    };
+    return l.delta(
+      { x: n(t, "x"), y: n(t, "y") },
+      { x: n(e, "x"), y: n(e, "y") }
+    );
+  }
+  static intersectionRatio(t, e) {
+    return h.from(t).intersectionRatio(h.from(e));
+  }
+};
+function tt(r, t) {
+  const e = Math.max(t.top, r.top), i = Math.max(t.left, r.left), n = Math.min(t.left + t.width, r.left + r.width), o = Math.min(t.top + t.height, r.top + r.height), s = n - i, c = o - e;
+  return i < n && e < o ? s * c : 0;
+}
+var b, q, w, y, f, m = class extends (w = W, q = [S], b = [S], w) {
+  constructor(r) {
+    const t = l.from(r);
+    super(t, (e, i) => l.equals(e, i)), X(f, 5, this), Z(this, y, 0), this.velocity = { x: 0, y: 0 };
+  }
+  get delta() {
+    return l.delta(this.current, this.initial);
+  }
+  get direction() {
+    const { current: r, previous: t } = this;
+    if (!t) return null;
+    const e = {
+      x: r.x - t.x,
+      y: r.y - t.y
+    };
+    return !e.x && !e.y ? null : Math.abs(e.x) > Math.abs(e.y) ? e.x > 0 ? "right" : "left" : e.y > 0 ? "down" : "up";
+  }
+  get current() {
+    return super.current;
+  }
+  set current(r) {
+    const { current: t } = this, e = l.from(r), i = {
+      x: e.x - t.x,
+      y: e.y - t.y
+    }, n = Date.now(), o = n - Y(this, y), s = (c) => Math.round(c / o * 100);
+    G(() => {
+      $(this, y, n), this.velocity = {
+        x: s(i.x),
+        y: s(i.y)
+      }, super.current = e;
+    });
+  }
+  reset(r = this.defaultValue) {
+    super.reset(l.from(r)), this.velocity = { x: 0, y: 0 };
+  }
+};
+f = L(w);
+y = /* @__PURE__ */ new WeakMap();
+D(f, 2, "delta", q, m);
+D(f, 2, "direction", b, m);
+U(f, m);
+function it({ x: r, y: t }, e) {
+  const i = Math.abs(r), n = Math.abs(t);
+  return typeof e == "number" ? Math.sqrt(A(i, 2) + A(n, 2)) > e : "x" in e && "y" in e ? i > e.x && n > e.y : "x" in e ? i > e.x : "y" in e ? n > e.y : !1;
+}
+var V = /* @__PURE__ */ ((r) => (r.Horizontal = "x", r.Vertical = "y", r))(V || {}), ot = Object.values(V);
+export {
+  ot as Axes,
+  V as Axis,
+  l as Point,
+  m as Position,
+  nt as Rectangle,
+  it as exceedsDistance
+};

package/dist/node_modules/@dnd-kit/react/hooks.js

@@ -0,0 +1,69 @@
+import { useEffect as p, useRef as s, useLayoutEffect as w, useMemo as y, useState as E, useCallback as k } from "react";
+import "../state/dist/index.js";
+import { flushSync as O } from "react-dom";
+import { currentValue as m } from "./utilities.js";
+import { effect as S, untracked as V } from "../../@preact/signals-core/dist/signals-core.module.js";
+var C = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u", a = C ? w : p;
+function L() {
+  const e = E(0)[1];
+  return k(() => {
+    e((t) => t + 1);
+  }, [e]);
+}
+function D(e, t) {
+  const n = s(/* @__PURE__ */ new Map()), r = L();
+  return a(() => {
+    if (!e) {
+      n.current.clear();
+      return;
+    }
+    return S(() => {
+      var o;
+      let c = !1, u = !1;
+      for (const d of n.current) {
+        const [f] = d, l = V(() => d[1]), i = e[f];
+        l !== i && (c = !0, n.current.set(f, i), u = (o = t?.(f, l, i)) != null ? o : !1);
+      }
+      c && (u ? O(r) : r());
+    });
+  }, [e]), y(
+    () => e && new Proxy(e, {
+      get(o, c) {
+        const u = o[c];
+        return n.current.set(c, u), u;
+      }
+    }),
+    [e]
+  );
+}
+function I(e, t) {
+  e();
+}
+function R(e) {
+  const t = s(e);
+  return a(() => {
+    t.current = e;
+  }, [e]), t;
+}
+function _(e, t, n = p, r = Object.is) {
+  const o = s(e);
+  n(() => {
+    const c = o.current;
+    r(e, c) || (o.current = e, t(e, c));
+  }, [t, e]);
+}
+function j(e, t) {
+  const n = s(m(e));
+  a(() => {
+    const r = m(e);
+    r !== n.current && (n.current = r, t(r));
+  });
+}
+export {
+  D as useDeepSignal,
+  I as useImmediateEffect,
+  a as useIsomorphicLayoutEffect,
+  R as useLatest,
+  j as useOnElementChange,
+  _ as useOnValueChange
+};

package/dist/node_modules/@dnd-kit/react/index.js

@@ -0,0 +1,235 @@
+import { useRef as b, useEffect as ar, createContext as or, memo as sr, useInsertionEffect as ir, forwardRef as cr, useState as F, useMemo as lr, startTransition as ur, useImperativeHandle as dr, useContext as vr } from "react";
+import { DragDropManager as W, defaultPreset as k } from "../dom/index.js";
+import { KeyboardSensor as Nr, PointerSensor as Jr } from "../dom/index.js";
+import { useLatest as h, useOnValueChange as L, useIsomorphicLayoutEffect as A } from "./hooks.js";
+import { deepEqual as fr, ValueHistory as pr, derived as H } from "../state/dist/index.js";
+import { jsxs as _r, jsx as gr } from "react/jsx-runtime";
+import { resolveCustomizable as R } from "../abstract/index.js";
+import { batch as hr } from "../../@preact/signals-core/dist/signals-core.module.js";
+var T = Object.getOwnPropertySymbols, mr = Object.prototype.hasOwnProperty, yr = Object.prototype.propertyIsEnumerable, xr = (e, r) => {
+  var t = {};
+  for (var n in e)
+    mr.call(e, n) && r.indexOf(n) < 0 && (t[n] = e[n]);
+  if (e != null && T)
+    for (var n of T(e))
+      r.indexOf(n) < 0 && yr.call(e, n) && (t[n] = e[n]);
+  return t;
+}, Dr = new W(), G = or(
+  Dr
+), wr = sr(
+  cr(({ children: e }, r) => {
+    const [t, n] = F(0), a = b(null), i = b(null), u = lr(
+      () => ({
+        renderer: {
+          get rendering() {
+            var c;
+            return (c = a.current) != null ? c : Promise.resolve();
+          }
+        },
+        trackRendering(c) {
+          a.current || (a.current = new Promise((d) => {
+            i.current = d;
+          })), ur(() => {
+            c(), n((d) => d + 1);
+          });
+        }
+      }),
+      []
+    );
+    return A(() => {
+      var c;
+      (c = i.current) == null || c.call(i), a.current = null;
+    }, [e, t]), dr(r, () => u), null;
+  })
+), z = [void 0, fr];
+function Wr(e) {
+  var r = e, {
+    children: t,
+    onCollision: n,
+    onBeforeDragStart: a,
+    onDragStart: i,
+    onDragMove: u,
+    onDragOver: c,
+    onDragEnd: d
+  } = r, f = xr(r, [
+    "children",
+    "onCollision",
+    "onBeforeDragStart",
+    "onDragStart",
+    "onDragMove",
+    "onDragOver",
+    "onDragEnd"
+  ]);
+  const p = b(null), { plugins: I, modifiers: M, sensors: w } = f, m = R(I, k.plugins), E = R(w, k.sensors), v = R(M, k.modifiers), y = h(a), _ = h(i), rr = h(c), er = h(u), tr = h(d), B = h(n), s = Er(() => {
+    var S;
+    return (S = f.manager) != null ? S : new W(f);
+  });
+  return ar(() => {
+    if (!p.current) throw new Error("Renderer not found");
+    const { renderer: S, trackRendering: O } = p.current, { monitor: g } = s;
+    s.renderer = S;
+    const nr = [
+      g.addEventListener("beforedragstart", (l) => {
+        const o = y.current;
+        o && O(() => o(l, s));
+      }),
+      g.addEventListener(
+        "dragstart",
+        (l) => {
+          var o;
+          return (o = _.current) == null ? void 0 : o.call(_, l, s);
+        }
+      ),
+      g.addEventListener("dragover", (l) => {
+        const o = rr.current;
+        o && O(() => o(l, s));
+      }),
+      g.addEventListener("dragmove", (l) => {
+        const o = er.current;
+        o && O(() => o(l, s));
+      }),
+      g.addEventListener("dragend", (l) => {
+        const o = tr.current;
+        o && O(() => o(l, s));
+      }),
+      g.addEventListener(
+        "collision",
+        (l) => {
+          var o;
+          return (o = B.current) == null ? void 0 : o.call(B, l, s);
+        }
+      )
+    ];
+    return () => nr.forEach((l) => l());
+  }, [s]), L(
+    m,
+    () => s && (s.plugins = m),
+    ...z
+  ), L(
+    E,
+    () => s && (s.sensors = E),
+    ...z
+  ), L(
+    v,
+    () => s && (s.modifiers = v),
+    ...z
+  ), /* @__PURE__ */ _r(G.Provider, { value: s, children: [
+    /* @__PURE__ */ gr(wr, { ref: p, children: t }),
+    t
+  ] });
+}
+function Er(e) {
+  const r = b(null);
+  return r.current || (r.current = e()), ir(() => () => {
+    var t;
+    return (t = r.current) == null ? void 0 : t.destroy();
+  }, []), r.current;
+}
+function Sr() {
+  return vr(G);
+}
+function Ar(e) {
+  var r;
+  const t = (r = Sr()) != null ? r : void 0, [n] = F(() => e(t));
+  return n.manager !== t && (n.manager = t), A(n.register, [t, n]), n;
+}
+var Or = Object.create, K = Object.defineProperty, Pr = Object.getOwnPropertyDescriptor, N = (e, r) => (r = Symbol[e]) ? r : /* @__PURE__ */ Symbol.for("Symbol." + e), C = (e) => {
+  throw TypeError(e);
+}, br = (e, r, t) => r in e ? K(e, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[r] = t, Cr = (e) => {
+  var r;
+  return [, , , Or((r = e?.[N("metadata")]) != null ? r : null)];
+}, J = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], Q = (e) => e !== void 0 && typeof e != "function" ? C("Function expected") : e, Ir = (e, r, t, n, a) => ({ kind: J[e], name: r, metadata: n, addInitializer: (i) => t._ ? C("Already initialized") : a.push(Q(i || null)) }), Mr = (e, r) => br(r, N("metadata"), e[3]), kr = (e, r, t, n) => {
+  for (var a = 0, i = e[r >> 1], u = i && i.length; a < u; a++) i[a].call(t);
+  return n;
+}, U = (e, r, t, n, a, i) => {
+  for (var u, c, d, f, p = r & 7, I = !1, M = !1, w = 2, m = J[p + 5], E = e[w] || (e[w] = []), v = (a = a.prototype, Pr(a, t)), y = n.length - 1; y >= 0; y--)
+    d = Ir(p, t, c = {}, e[3], E), d.static = I, d.private = M, f = d.access = { has: (_) => t in _ }, f.get = (_) => _[t], u = (0, n[y])(v[m], d), c._ = 1, Q(u) && (v[m] = u);
+  return v && K(a, t, v), a;
+}, X = (e, r, t) => r.has(e) || C("Cannot " + t), Lr = (e, r, t) => (X(e, r, "read from private field"), r.get(e)), Rr = (e, r, t) => r.has(e) ? C("Cannot add the same private member more than once") : r instanceof WeakSet ? r.add(e) : r.set(e, t), zr = (e, r, t, n) => (X(e, r, "write to private field"), r.set(e, t), t), x = class j {
+  /**
+   * @param {number} Coordinate of the point on the horizontal axis
+   * @param {number} Coordinate of the point on the vertical axis
+   */
+  constructor(r, t) {
+    this.x = r, this.y = t;
+  }
+  /**
+   * Returns the delta between this point and another point.
+   *
+   * @param {Point} a - A point
+   * @param {Point} b - Another point
+   */
+  static delta(r, t) {
+    return new j(r.x - t.x, r.y - t.y);
+  }
+  /**
+   * Returns the distance (hypotenuse) between this point and another point.
+   *
+   * @param {Point} a - A point
+   * @param {Point} b - Another point
+   */
+  static distance(r, t) {
+    return Math.hypot(r.x - t.x, r.y - t.y);
+  }
+  /**
+   * Returns true if both points are equal.
+   *
+   * @param {Point} a - A point
+   * @param {Point} b - Another point
+   */
+  static equals(r, t) {
+    return r.x === t.x && r.y === t.y;
+  }
+  static from({ x: r, y: t }) {
+    return new j(r, t);
+  }
+}, Y, Z, V, P, D, q = class extends (V = pr, Z = [H], Y = [H], V) {
+  constructor(e) {
+    const r = x.from(e);
+    super(r, (t, n) => x.equals(t, n)), kr(D, 5, this), Rr(this, P, 0), this.velocity = { x: 0, y: 0 };
+  }
+  get delta() {
+    return x.delta(this.current, this.initial);
+  }
+  get direction() {
+    const { current: e, previous: r } = this;
+    if (!r) return null;
+    const t = {
+      x: e.x - r.x,
+      y: e.y - r.y
+    };
+    return !t.x && !t.y ? null : Math.abs(t.x) > Math.abs(t.y) ? t.x > 0 ? "right" : "left" : t.y > 0 ? "down" : "up";
+  }
+  get current() {
+    return super.current;
+  }
+  set current(e) {
+    const { current: r } = this, t = x.from(e), n = {
+      x: t.x - r.x,
+      y: t.y - r.y
+    }, a = Date.now(), i = a - Lr(this, P), u = (c) => Math.round(c / i * 100);
+    hr(() => {
+      zr(this, P, a), this.velocity = {
+        x: u(n.x),
+        y: u(n.y)
+      }, super.current = t;
+    });
+  }
+  reset(e = this.defaultValue) {
+    super.reset(x.from(e)), this.velocity = { x: 0, y: 0 };
+  }
+};
+D = Cr(V);
+P = /* @__PURE__ */ new WeakMap();
+U(D, 2, "delta", Z, q);
+U(D, 2, "direction", Y, q);
+Mr(D, q);
+var $ = /* @__PURE__ */ ((e) => (e.Horizontal = "x", e.Vertical = "y", e))($ || {});
+Object.values($);
+export {
+  Wr as DragDropProvider,
+  Nr as KeyboardSensor,
+  Jr as PointerSensor,
+  Sr as useDragDropManager,
+  Ar as useInstance
+};

package/dist/node_modules/@dnd-kit/react/sortable.js

@@ -0,0 +1,129 @@
+import { useCallback as c } from "react";
+import { deepEqual as f } from "../state/dist/index.js";
+import { defaultSortableTransition as x, Sortable as R } from "../dom/sortable.js";
+import { isSortable as rr } from "../dom/sortable.js";
+import { useInstance as T } from "./index.js";
+import { useDeepSignal as V, useOnValueChange as i, useIsomorphicLayoutEffect as k, useImmediateEffect as q, useOnElementChange as m } from "./hooks.js";
+import { currentValue as v } from "./utilities.js";
+import { batch as L } from "../../@preact/signals-core/dist/signals-core.module.js";
+var N = Object.defineProperty, U = Object.defineProperties, z = Object.getOwnPropertyDescriptors, I = Object.getOwnPropertySymbols, A = Object.prototype.hasOwnProperty, B = Object.prototype.propertyIsEnumerable, j = (o, t, a) => t in o ? N(o, t, { enumerable: !0, configurable: !0, writable: !0, value: a }) : o[t] = a, _ = (o, t) => {
+  for (var a in t || (t = {}))
+    A.call(t, a) && j(o, a, t[a]);
+  if (I)
+    for (var a of I(t))
+      B.call(t, a) && j(o, a, t[a]);
+  return o;
+}, F = (o, t) => U(o, z(t));
+function Y(o) {
+  const {
+    accept: t,
+    collisionDetector: a,
+    collisionPriority: b,
+    id: O,
+    data: p,
+    element: h,
+    handle: y,
+    index: g,
+    group: D,
+    disabled: P,
+    feedback: d,
+    modifiers: S,
+    sensors: w,
+    target: C,
+    type: E
+  } = o, l = _(_({}, x), o.transition), r = T((e) => new R(
+    F(_({}, o), {
+      transition: l,
+      register: !1,
+      handle: v(y),
+      element: v(h),
+      target: v(C),
+      feedback: d
+    }),
+    e
+  )), u = V(r, G);
+  return i(O, () => r.id = O), k(() => {
+    L(() => {
+      r.group = D, r.index = g;
+    });
+  }, [r, D, g]), i(E, () => r.type = E), i(
+    t,
+    () => r.accept = t,
+    void 0,
+    f
+  ), i(p, () => p && (r.data = p)), i(
+    g,
+    () => {
+      var e;
+      (e = r.manager) != null && e.dragOperation.status.idle && l?.idle && r.refreshShape();
+    },
+    q
+  ), m(y, (e) => r.handle = e), m(h, (e) => r.element = e), m(C, (e) => r.target = e), i(P, () => r.disabled = P === !0), i(w, () => r.sensors = w), i(
+    a,
+    () => r.collisionDetector = a
+  ), i(
+    b,
+    () => r.collisionPriority = b
+  ), i(d, () => r.feedback = d ?? "default"), i(
+    l,
+    () => r.transition = l,
+    void 0,
+    f
+  ), i(
+    S,
+    () => r.modifiers = S,
+    void 0,
+    f
+  ), i(
+    o.alignment,
+    () => r.alignment = o.alignment
+  ), {
+    sortable: u,
+    get isDragging() {
+      return u.isDragging;
+    },
+    get isDropping() {
+      return u.isDropping;
+    },
+    get isDragSource() {
+      return u.isDragSource;
+    },
+    get isDropTarget() {
+      return u.isDropTarget;
+    },
+    handleRef: c(
+      (e) => {
+        r.handle = e ?? void 0;
+      },
+      [r]
+    ),
+    ref: c(
+      (e) => {
+        var n, s;
+        !e && ((n = r.element) != null && n.isConnected) && !((s = r.manager) != null && s.dragOperation.status.idle) || (r.element = e ?? void 0);
+      },
+      [r]
+    ),
+    sourceRef: c(
+      (e) => {
+        var n, s;
+        !e && ((n = r.source) != null && n.isConnected) && !((s = r.manager) != null && s.dragOperation.status.idle) || (r.source = e ?? void 0);
+      },
+      [r]
+    ),
+    targetRef: c(
+      (e) => {
+        var n, s;
+        !e && ((n = r.target) != null && n.isConnected) && !((s = r.manager) != null && s.dragOperation.status.idle) || (r.target = e ?? void 0);
+      },
+      [r]
+    )
+  };
+}
+function G(o, t, a) {
+  return !!(o === "isDragSource" && !a && t);
+}
+export {
+  rr as isSortable,
+  Y as useSortable
+};

package/dist/node_modules/@dnd-kit/react/utilities.js

@@ -0,0 +1,11 @@
+function t(r) {
+  return r != null && typeof r == "object" && "current" in r;
+}
+function i(r) {
+  var n;
+  if (r != null)
+    return t(r) ? (n = r.current) != null ? n : void 0 : r;
+}
+export {
+  i as currentValue
+};