@caspeco/casper-ui-library 8.2.2 → 8.4.0

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

@@ -0,0 +1,1554 @@
+import { Plugin as ue, DragDropManager as ur, resolveCustomizable as qe, Sensor as Te, ActivationController as hr, CorePlugin as ft, descriptor as fr, Droppable as pr, Draggable as vr, configurator as pt, ActivationConstraint as an } from "../abstract/index.js";
+import { getRoot as $e, generateUniqueId as et, isSafari as mr, scheduler as Me, Listeners as ln, isElement as le, isHTMLElement as cn, getFrameTransform as Ie, getEventCoordinates as ce, getDocuments as gr, getDocument as Ne, scrollIntoViewIfNeeded as br, DOMRectangle as N, canScroll as yr, detectScrollIntent as _r, isKeyboardEvent as vt, isInteractiveElement as wr, isTextInput as Sr, getScrollableAncestors as Ht, ScrollDirection as R, PositionObserver as Er, isDocument as xr, isShadowRoot as kr, getComputedStyles as dn, parseTranslate as un, getFixedPositionOffset as hn, Styles as Ar, supportsPopover as Vt, showPopover as we, getWindow as fn, prefersReducedMotion as pn, getElementFromPoint as Dr, isPointerEvent as Or, getFrameElement as qt, cloneElement as Cr, supportsStyle as Gt, getFinalKeyframe as Pr, animateTransform as Tr, ProxiedElements as Jt } from "./utilities.js";
+import { computed as tt, deepEqual as $r, effects as Mr, reactive as F, derived as Ge } from "../state/dist/index.js";
+import { Axes as vn, Point as Ir, Rectangle as mn, exceedsDistance as nt } from "../geometry/dist/index.js";
+import { defaultCollisionDetection as Rr } from "../collision/dist/index.js";
+import { untracked as M, effect as J, signal as gn, batch as Wr } from "../../@preact/signals-core/dist/signals-core.module.js";
+var Lr = Object.create, mt = Object.defineProperty, Fr = Object.defineProperties, zr = Object.getOwnPropertyDescriptor, Nr = Object.getOwnPropertyDescriptors, Re = Object.getOwnPropertySymbols, bn = Object.prototype.hasOwnProperty, yn = Object.prototype.propertyIsEnumerable, _n = (e, t) => (t = Symbol[e]) ? t : /* @__PURE__ */ Symbol.for("Symbol." + e), he = (e) => {
+  throw TypeError(e);
+}, rt = (e, t, n) => t in e ? mt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, Se = (e, t) => {
+  for (var n in t || (t = {}))
+    bn.call(t, n) && rt(e, n, t[n]);
+  if (Re)
+    for (var n of Re(t))
+      yn.call(t, n) && rt(e, n, t[n]);
+  return e;
+}, gt = (e, t) => Fr(e, Nr(t)), Qt = (e, t) => mt(e, "name", { value: t, configurable: !0 }), wn = (e, t) => {
+  var n = {};
+  for (var r in e)
+    bn.call(e, r) && t.indexOf(r) < 0 && (n[r] = e[r]);
+  if (e != null && Re)
+    for (var r of Re(e))
+      t.indexOf(r) < 0 && yn.call(e, r) && (n[r] = e[r]);
+  return n;
+}, fe = (e) => {
+  var t;
+  return [, , , Lr((t = e?.[_n("metadata")]) != null ? t : null)];
+}, Sn = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], me = (e) => e !== void 0 && typeof e != "function" ? he("Function expected") : e, Kr = (e, t, n, r, i) => ({ kind: Sn[e], name: t, metadata: r, addInitializer: (s) => n._ ? he("Already initialized") : i.push(me(s || null)) }), Q = (e, t) => rt(t, _n("metadata"), e[3]), x = (e, t, n, r) => {
+  for (var i = 0, s = e[t >> 1], o = s && s.length; i < o; i++) t & 1 ? s[i].call(n) : r = s[i].call(n, r);
+  return r;
+}, $ = (e, t, n, r, i, s) => {
+  var o, a, l, f, d, c = t & 7, h = !!(t & 8), u = !!(t & 16), p = c > 3 ? e.length + 1 : c ? h ? 1 : 2 : 0, w = Sn[c + 5], k = c > 3 && (e[p - 1] = []), C = e[p] || (e[p] = []), b = c && (!u && !h && (i = i.prototype), c < 5 && (c > 3 || !u) && zr(c < 4 ? i : { get [n]() {
+    return y(this, s);
+  }, set [n](m) {
+    return O(this, s, m);
+  } }, n));
+  c ? u && c < 4 && Qt(s, (c > 2 ? "set " : c > 1 ? "get " : "") + n) : Qt(i, n);
+  for (var g = r.length - 1; g >= 0; g--)
+    f = Kr(c, n, l = {}, e[3], C), c && (f.static = h, f.private = u, d = f.access = { has: u ? (m) => Ur(i, m) : (m) => n in m }, c ^ 3 && (d.get = u ? (m) => (c ^ 1 ? y : G)(m, i, c ^ 4 ? s : b.get) : (m) => m[n]), c > 2 && (d.set = u ? (m, v) => O(m, i, v, c ^ 4 ? s : b.set) : (m, v) => m[n] = v)), a = (0, r[g])(c ? c < 4 ? u ? s : b[w] : c > 4 ? void 0 : { get: b.get, set: b.set } : i, f), l._ = 1, c ^ 4 || a === void 0 ? me(a) && (c > 4 ? k.unshift(a) : c ? u ? s = a : b[w] = a : i = a) : typeof a != "object" || a === null ? he("Object expected") : (me(o = a.get) && (b.get = o), me(o = a.set) && (b.set = o), me(o = a.init) && k.unshift(o));
+  return c || Q(e, i), b && mt(i, n, b), u ? c ^ 4 ? s : b : i;
+}, bt = (e, t, n) => t.has(e) || he("Cannot " + n), Ur = (e, t) => Object(t) !== t ? he('Cannot use the "in" operator on this value') : e.has(t), y = (e, t, n) => (bt(e, t, "read from private field"), n ? n.call(e) : t.get(e)), E = (e, t, n) => t.has(e) ? he("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), O = (e, t, n, r) => (bt(e, t, "write to private field"), r ? r.call(e, n) : t.set(e, n), n), G = (e, t, n) => (bt(e, t, "access private method"), n), Zt = {
+  role: "button",
+  roleDescription: "draggable"
+}, Xr = "dnd-kit-description", Yr = "dnd-kit-announcement", jr = {
+  draggable: "To pick up a draggable item, press the space bar. While dragging, use the arrow keys to move the item in a given direction. Press space again to drop the item in its new position, or press escape to cancel."
+}, Br = {
+  dragstart({ operation: { source: e } }) {
+    if (e)
+      return `Picked up draggable item ${e.id}.`;
+  },
+  dragover({ operation: { source: e, target: t } }) {
+    if (!(!e || e.id === t?.id))
+      return t ? `Draggable item ${e.id} was moved over droppable target ${t.id}.` : `Draggable item ${e.id} is no longer over a droppable target.`;
+  },
+  dragend({ operation: { source: e, target: t }, canceled: n }) {
+    if (e)
+      return n ? `Dragging was cancelled. Draggable item ${e.id} was dropped.` : t ? `Draggable item ${e.id} was dropped over droppable target ${t.id}` : `Draggable item ${e.id} was dropped.`;
+  }
+};
+function Hr(e) {
+  const t = e.tagName.toLowerCase();
+  return ["input", "select", "textarea", "a", "button"].includes(t);
+}
+function Vr(e, t) {
+  const n = document.createElement("div");
+  return n.id = e, n.style.setProperty("display", "none"), n.textContent = t, n;
+}
+function qr(e) {
+  const t = document.createElement("div");
+  return t.id = e, t.setAttribute("role", "status"), t.setAttribute("aria-live", "polite"), t.setAttribute("aria-atomic", "true"), t.style.setProperty("position", "fixed"), t.style.setProperty("width", "1px"), t.style.setProperty("height", "1px"), t.style.setProperty("margin", "-1px"), t.style.setProperty("border", "0"), t.style.setProperty("padding", "0"), t.style.setProperty("overflow", "hidden"), t.style.setProperty("clip", "rect(0 0 0 0)"), t.style.setProperty("clip-path", "inset(100%)"), t.style.setProperty("white-space", "nowrap"), t;
+}
+var Gr = ["dragover", "dragmove"], Jr = class extends ue {
+  constructor(e, t) {
+    super(e);
+    const {
+      id: n,
+      idPrefix: {
+        description: r = Xr,
+        announcement: i = Yr
+      } = {},
+      announcements: s = Br,
+      screenReaderInstructions: o = jr,
+      debounce: a = 500
+    } = t ?? {}, l = n ? `${r}-${n}` : et(r), f = n ? `${i}-${n}` : et(i);
+    let d, c, h, u;
+    const p = (v = u) => {
+      !h || !v || h?.nodeValue !== v && (h.nodeValue = v);
+    }, w = () => Me.schedule(p), k = Qr(
+      w,
+      a
+    ), C = Object.entries(s).map(
+      ([v, P]) => this.manager.monitor.addEventListener(
+        v,
+        (S, z) => {
+          const U = h;
+          if (!U) return;
+          const X = P?.(S, z);
+          X && U.nodeValue !== X && (u = X, Gr.includes(v) ? k() : (w(), k.cancel()));
+        }
+      )
+    ), b = () => {
+      let v = [];
+      d?.isConnected || (d = Vr(
+        l,
+        o.draggable
+      ), v.push(d)), c?.isConnected || (c = qr(f), h = document.createTextNode(""), c.appendChild(h), v.push(c)), v.length > 0 && document.body.append(...v);
+    }, g = /* @__PURE__ */ new Set();
+    function m() {
+      for (const v of g)
+        v();
+    }
+    this.registerEffect(() => {
+      var v;
+      g.clear();
+      for (const P of this.manager.registry.draggables.value) {
+        const S = (v = P.handle) != null ? v : P.element;
+        if (S) {
+          (!d || !c) && g.add(b), (!Hr(S) || mr()) && !S.hasAttribute("tabindex") && g.add(() => S.setAttribute("tabindex", "0")), !S.hasAttribute("role") && S.tagName.toLowerCase() !== "button" && g.add(
+            () => S.setAttribute("role", Zt.role)
+          ), S.hasAttribute("aria-roledescription") || g.add(
+            () => S.setAttribute(
+              "aria-roledescription",
+              Zt.roleDescription
+            )
+          ), S.hasAttribute("aria-describedby") || g.add(
+            () => S.setAttribute("aria-describedby", l)
+          );
+          for (const U of ["aria-pressed", "aria-grabbed"]) {
+            const X = String(P.isDragging);
+            S.getAttribute(U) !== X && g.add(() => S.setAttribute(U, X));
+          }
+          const z = String(P.disabled);
+          S.getAttribute("aria-disabled") !== z && g.add(
+            () => S.setAttribute("aria-disabled", z)
+          );
+        }
+      }
+      g.size > 0 && Me.schedule(m);
+    }), this.destroy = () => {
+      super.destroy(), d?.remove(), c?.remove(), C.forEach((v) => v());
+    };
+  }
+};
+function Qr(e, t) {
+  let n;
+  const r = () => {
+    clearTimeout(n), n = setTimeout(e, t);
+  };
+  return r.cancel = () => clearTimeout(n), r;
+}
+var Zr = class extends ue {
+  constructor(e, t) {
+    super(e, t), this.manager = e;
+    const n = tt(
+      () => {
+        var r;
+        return Ne((r = this.manager.dragOperation.source) == null ? void 0 : r.element);
+      }
+    );
+    this.destroy = J(() => {
+      var r;
+      const { dragOperation: i } = this.manager, { cursor: s = "grabbing", nonce: o } = (r = this.options) != null ? r : {};
+      if (i.status.initialized) {
+        const a = n.value, l = a.createElement("style");
+        return o && l.setAttribute("nonce", o), l.textContent = `* { cursor: ${s} !important; }`, a.head.appendChild(l), () => l.remove();
+      }
+    });
+  }
+}, We = /* @__PURE__ */ new Map(), En, xn, kn, An, it, ye, K, yt, de, Dn, On, Cn, Pn, Z = class extends (it = ft, An = [F], kn = [Ge], xn = [Ge], En = [Ge], it) {
+  constructor(e) {
+    super(e), x(K, 5, this), E(this, de), E(this, ye, /* @__PURE__ */ new Set()), E(this, yt, x(K, 8, this, /* @__PURE__ */ new Set())), x(K, 11, this), this.registerEffect(G(this, de, Dn));
+  }
+  /**
+   * Registers CSS rules to be injected into the active drag operation's
+   * document and shadow roots. The StyleSheetManager handles tracking
+   * which roots need the styles and cleaning up when they're no longer needed.
+   *
+   * Returns a cleanup function that unregisters the rules.
+   */
+  register(e) {
+    return y(this, ye).add(e), () => {
+      y(this, ye).delete(e);
+    };
+  }
+  /**
+   * Adds an additional root to track for style injection.
+   * Returns a cleanup function that removes the root.
+   */
+  addRoot(e) {
+    return M(() => {
+      const t = new Set(this.additionalRoots);
+      t.add(e), this.additionalRoots = t;
+    }), () => {
+      M(() => {
+        const t = new Set(this.additionalRoots);
+        t.delete(e), this.additionalRoots = t;
+      });
+    };
+  }
+  get sourceRoot() {
+    var e;
+    const { source: t } = this.manager.dragOperation;
+    return $e((e = t?.element) != null ? e : null);
+  }
+  get targetRoot() {
+    var e;
+    const { target: t } = this.manager.dragOperation;
+    return $e((e = t?.element) != null ? e : null);
+  }
+  get roots() {
+    const { status: e } = this.manager.dragOperation;
+    if (e.initializing || e.initialized) {
+      const t = [this.sourceRoot, this.targetRoot].filter(
+        (n) => n != null
+      );
+      return /* @__PURE__ */ new Set([...t, ...this.additionalRoots]);
+    }
+    return /* @__PURE__ */ new Set();
+  }
+};
+K = fe(it);
+ye = /* @__PURE__ */ new WeakMap();
+yt = /* @__PURE__ */ new WeakMap();
+de = /* @__PURE__ */ new WeakSet();
+Dn = function() {
+  const { roots: e } = this, t = [];
+  for (const n of e)
+    for (const r of y(this, ye))
+      t.push(G(this, de, On).call(this, n, r));
+  return () => {
+    for (const n of t)
+      n();
+  };
+};
+On = function(e, t) {
+  let n = We.get(e);
+  n || (n = /* @__PURE__ */ new Map(), We.set(e, n));
+  let r = n.get(t);
+  if (!r) {
+    const s = xr(e) ? G(this, de, Cn).call(this, e, n, t) : G(this, de, Pn).call(this, e, n, t);
+    if (!s)
+      return () => {
+      };
+    r = s, n.set(t, r);
+  }
+  r.refCount++;
+  let i = !1;
+  return () => {
+    i || (i = !0, r.refCount--, r.refCount === 0 && r.cleanup());
+  };
+};
+Cn = function(e, t, n) {
+  const r = e.createElement("style");
+  r.textContent = n, e.head.prepend(r);
+  const i = new MutationObserver((s) => {
+    for (const o of s)
+      for (const a of Array.from(o.removedNodes))
+        if (a === r) {
+          e.head.prepend(r);
+          return;
+        }
+  });
+  return i.observe(e.head, { childList: !0 }), {
+    refCount: 0,
+    cleanup: () => {
+      i.disconnect(), r.remove(), t.delete(n), t.size === 0 && We.delete(e);
+    }
+  };
+};
+Pn = function(e, t, n) {
+  !("adoptedStyleSheets" in e && Array.isArray(e.adoptedStyleSheets)) && process.env.NODE_ENV !== "production" && console.error(
+    "Cannot inject styles: This browser doesn't support adoptedStyleSheets"
+  );
+  const r = e.ownerDocument.defaultView, { CSSStyleSheet: i } = r ?? {};
+  if (!i)
+    return process.env.NODE_ENV !== "production" && console.error(
+      "Cannot inject styles: CSSStyleSheet constructor not available"
+    ), null;
+  const s = new i();
+  return s.replaceSync(n), e.adoptedStyleSheets.push(s), {
+    refCount: 0,
+    cleanup: () => {
+      var o;
+      if (kr(e) && ((o = e.host) != null && o.isConnected)) {
+        const a = e.adoptedStyleSheets.indexOf(s);
+        a !== -1 && e.adoptedStyleSheets.splice(a, 1);
+      }
+      t.delete(n), t.size === 0 && We.delete(e);
+    }
+  };
+};
+$(K, 4, "additionalRoots", An, Z, yt);
+$(K, 2, "sourceRoot", kn, Z);
+$(K, 2, "targetRoot", xn, Z);
+$(K, 2, "roots", En, Z);
+Q(K, Z);
+var De = "data-dnd-", st = `${De}dropping`, D = "--dnd-", L = `${De}dragging`, Le = `${De}placeholder`, ei = [
+  L,
+  Le,
+  "popover",
+  "aria-pressed",
+  "aria-grabbing"
+], ti = ["view-transition-name"], ni = `
+  :is(:root,:host) [${L}] {
+    position: fixed !important;
+    pointer-events: none !important;
+    touch-action: none;
+    z-index: calc(infinity);
+    will-change: translate;
+    top: var(${D}top, 0px) !important;
+    left: var(${D}left, 0px) !important;
+    right: unset !important;
+    bottom: unset !important;
+    width: var(${D}width, auto);
+    max-width: var(${D}width, auto);
+    height: var(${D}height, auto);
+    max-height: var(${D}height, auto);
+    transition: var(${D}transition) !important;
+  }
+
+  :is(:root,:host) [${Le}] {
+    transition: none;
+  }
+
+  :is(:root,:host) [${Le}='hidden'] {
+    visibility: hidden;
+  }
+
+  [${L}] * {
+    pointer-events: none !important;
+  }
+
+  [${L}]:not([${st}]) {
+    translate: var(${D}translate) !important;
+  }
+
+  [${L}][style*='${D}scale'] {
+    scale: var(${D}scale) !important;
+    transform-origin: var(${D}transform-origin) !important;
+  }
+
+  @layer dnd-kit {
+    :where([${L}][popover]) {
+      overflow: visible;
+      background: unset;
+      border: unset;
+      margin: unset;
+      padding: unset;
+      color: inherit;
+
+      &:is(input, button) {
+        border: revert;
+        background: revert;
+      }
+    }
+  }
+  [${L}]::backdrop, [${De}overlay]:not([${L}]) {
+    display: none;
+    visibility: hidden;
+  }
+`.replace(/\n+/g, " ").replace(/\s+/g, " ").trim();
+function ri(e, t = "hidden") {
+  return M(() => {
+    const { element: n, manager: r } = e;
+    if (!n || !r) return;
+    const i = ii(
+      n,
+      r.registry.droppables
+    ), s = [], o = Cr(n), { remove: a } = o;
+    return si(i, o, s), oi(o, t), o.remove = () => {
+      s.forEach((l) => l()), a.call(o);
+    }, o;
+  });
+}
+function ii(e, t) {
+  const n = /* @__PURE__ */ new Map();
+  for (const r of t)
+    if (r.element && (e === r.element || e.contains(r.element))) {
+      const i = `${De}${et("dom-id")}`;
+      r.element.setAttribute(i, ""), n.set(r, i);
+    }
+  return n;
+}
+function si(e, t, n) {
+  for (const [r, i] of e) {
+    if (!r.element) continue;
+    const s = `[${i}]`, o = t.matches(s) ? t : t.querySelector(s);
+    if (r.element.removeAttribute(i), !o) continue;
+    const a = r.element;
+    r.proxy = o, o.removeAttribute(i), Jt.set(a, o), n.push(() => {
+      Jt.delete(a), r.proxy = void 0;
+    });
+  }
+}
+function oi(e, t = "hidden") {
+  e.setAttribute("inert", "true"), e.setAttribute("tab-index", "-1"), e.setAttribute("aria-hidden", "true"), e.setAttribute(Le, t);
+}
+function Tn(e, t) {
+  return e === t ? !0 : qt(e) === qt(t);
+}
+function en(e) {
+  const { target: t } = e;
+  "newState" in e && e.newState === "closed" && le(t) && t.hasAttribute("popover") && requestAnimationFrame(() => we(t));
+}
+function ot(e) {
+  return e.tagName === "TR";
+}
+function ai(e, t, n) {
+  const r = new MutationObserver((i) => {
+    let s = !1;
+    for (const o of i) {
+      if (o.target !== e) {
+        s = !0;
+        continue;
+      }
+      if (o.type !== "attributes")
+        continue;
+      const a = o.attributeName;
+      if (a.startsWith("aria-") || ei.includes(a))
+        continue;
+      const l = e.getAttribute(a);
+      if (a === "style") {
+        if (Gt(e) && Gt(t)) {
+          const f = e.style;
+          for (const d of Array.from(t.style))
+            f.getPropertyValue(d) === "" && t.style.removeProperty(d);
+          for (const d of Array.from(f)) {
+            if (ti.includes(d) || d.startsWith(D))
+              continue;
+            const c = f.getPropertyValue(d);
+            t.style.setProperty(d, c);
+          }
+        }
+      } else l !== null ? t.setAttribute(a, l) : t.removeAttribute(a);
+    }
+    s && n && (t.innerHTML = e.innerHTML);
+  });
+  return r.observe(e, {
+    attributes: !0,
+    subtree: !0,
+    childList: !0
+  }), r;
+}
+function li(e, t, n) {
+  const r = new MutationObserver((i) => {
+    for (const s of i)
+      if (s.addedNodes.length !== 0)
+        for (const o of Array.from(s.addedNodes)) {
+          if (o.contains(e) && e.nextElementSibling !== t) {
+            e.insertAdjacentElement("afterend", t), we(n);
+            return;
+          }
+          if (o.contains(t) && t.previousElementSibling !== e) {
+            t.insertAdjacentElement("beforebegin", e), we(n);
+            return;
+          }
+        }
+  });
+  return r.observe(e.ownerDocument.body, {
+    childList: !0,
+    subtree: !0
+  }), r;
+}
+function ci(e) {
+  return new ResizeObserver(() => {
+    var t, n;
+    const r = new N(e.placeholder, {
+      frameTransform: e.frameTransform,
+      ignoreTransforms: !0
+    }), i = (t = e.transformOrigin) != null ? t : { x: 1, y: 1 }, s = (e.width - r.width) * i.x + e.delta.x, o = (e.height - r.height) * i.y + e.delta.y, a = hn();
+    if (e.styles.set(
+      {
+        width: r.width - e.widthOffset,
+        height: r.height - e.heightOffset,
+        top: e.top + o + a.y,
+        left: e.left + s + a.x
+      },
+      D
+    ), (n = e.getElementMutationObserver()) == null || n.takeRecords(), ot(e.element) && ot(e.placeholder)) {
+      const l = Array.from(e.element.cells), f = Array.from(e.placeholder.cells);
+      e.getSavedCellWidths() || e.setSavedCellWidths(l.map((d) => d.style.width));
+      for (const [d, c] of l.entries()) {
+        const h = f[d];
+        c.style.width = `${h.getBoundingClientRect().width}px`;
+      }
+    }
+    e.dragOperation.shape = new N(e.feedbackElement);
+  });
+}
+var di = 250, ui = "ease";
+function hi(e) {
+  var t, n, r, i;
+  const { animation: s } = e;
+  if (typeof s == "function") {
+    const b = s({
+      element: e.element,
+      feedbackElement: e.feedbackElement,
+      placeholder: e.placeholder,
+      translate: e.translate,
+      moved: e.moved
+    });
+    Promise.resolve(b).then(() => {
+      e.cleanup(), requestAnimationFrame(e.restoreFocus);
+    });
+    return;
+  }
+  const {
+    duration: o = di,
+    easing: a = ui
+  } = s ?? {};
+  we(e.feedbackElement);
+  const [, l] = (t = Pr(
+    e.feedbackElement,
+    (b) => "translate" in b
+  )) != null ? t : [];
+  l?.pause();
+  const f = (n = e.placeholder) != null ? n : e.element, d = {
+    frameTransform: Tn(e.feedbackElement, f) ? null : void 0
+  }, c = new N(e.feedbackElement, d), h = (r = un(dn(e.feedbackElement).translate)) != null ? r : e.translate, u = new N(f, d), p = mn.delta(c, u, e.alignment), w = {
+    x: h.x - p.x,
+    y: h.y - p.y
+  }, k = Math.round(c.intrinsicHeight) !== Math.round(u.intrinsicHeight) ? {
+    minHeight: [
+      `${c.intrinsicHeight}px`,
+      `${u.intrinsicHeight}px`
+    ],
+    maxHeight: [
+      `${c.intrinsicHeight}px`,
+      `${u.intrinsicHeight}px`
+    ]
+  } : {}, C = Math.round(c.intrinsicWidth) !== Math.round(u.intrinsicWidth) ? {
+    minWidth: [
+      `${c.intrinsicWidth}px`,
+      `${u.intrinsicWidth}px`
+    ],
+    maxWidth: [
+      `${c.intrinsicWidth}px`,
+      `${u.intrinsicWidth}px`
+    ]
+  } : {};
+  e.styles.set({ transition: e.transition }, D), e.feedbackElement.setAttribute(st, ""), (i = e.getElementMutationObserver()) == null || i.takeRecords(), Tr({
+    element: e.feedbackElement,
+    keyframes: gt(Se(Se({}, k), C), {
+      translate: [
+        `${h.x}px ${h.y}px 0`,
+        `${w.x}px ${w.y}px 0`
+      ]
+    }),
+    options: {
+      duration: pn(fn(e.feedbackElement)) ? 0 : e.moved || e.feedbackElement !== e.element ? o : 0,
+      easing: a
+    }
+  }).then(() => {
+    e.feedbackElement.removeAttribute(st), l?.finish(), e.cleanup(), requestAnimationFrame(e.restoreFocus);
+  });
+}
+var $n, at, Ee, _t, Pe, Mn, In, xe = class extends (at = ue, $n = [F], at) {
+  constructor(t, n) {
+    super(t, n), E(this, Pe), E(this, _t, x(Ee, 8, this)), x(Ee, 11, this), this.state = {
+      initial: {},
+      current: {}
+    };
+    const r = t.registry.plugins.get(
+      Z
+    ), i = r?.register(ni);
+    if (i) {
+      const s = this.destroy.bind(this);
+      this.destroy = () => {
+        i(), s();
+      };
+    }
+    this.registerEffect(G(this, Pe, Mn).bind(this, r)), this.registerEffect(G(this, Pe, In));
+  }
+};
+Ee = fe(at);
+_t = /* @__PURE__ */ new WeakMap();
+Pe = /* @__PURE__ */ new WeakSet();
+Mn = function(e) {
+  const { overlay: t } = this;
+  if (!t || !e) return;
+  const n = $e(t);
+  if (n)
+    return e.addRoot(n);
+};
+In = function() {
+  var e, t, n;
+  const { state: r, manager: i, options: s } = this, { dragOperation: o } = i, { position: a, source: l, status: f } = o;
+  if (f.idle) {
+    r.current = {}, r.initial = {};
+    return;
+  }
+  if (!l) return;
+  const { element: d, feedback: c } = l;
+  if (!d || c === "none" || !f.initialized || f.initializing)
+    return;
+  const { initial: h } = r, u = (e = this.overlay) != null ? e : d, p = Ie(u), w = Ie(d), k = !Tn(d, u), C = new N(d, {
+    frameTransform: k ? w : null,
+    ignoreTransforms: !k
+  }), b = {
+    x: w.scaleX / p.scaleX,
+    y: w.scaleY / p.scaleY
+  };
+  let { width: g, height: m, top: v, left: P } = C;
+  k && (g = g / b.x, m = m / b.y);
+  const S = new Ar(u), {
+    transition: z,
+    translate: U,
+    boxSizing: X,
+    paddingBlockStart: qn,
+    paddingBlockEnd: Gn,
+    paddingInlineStart: Jn,
+    paddingInlineEnd: Qn,
+    borderInlineStartWidth: Zn,
+    borderInlineEndWidth: er,
+    borderBlockStartWidth: tr,
+    borderBlockEndWidth: nr
+  } = dn(d), Ct = c === "clone", Pt = X === "content-box", Tt = Pt ? parseInt(Jn) + parseInt(Qn) + parseInt(Zn) + parseInt(er) : 0, $t = Pt ? parseInt(qn) + parseInt(Gn) + parseInt(tr) + parseInt(nr) : 0, T = c !== "move" && !this.overlay ? ri(l, Ct ? "clone" : "hidden") : null, Xe = M(
+    () => vt(i.dragOperation.activatorEvent)
+  );
+  if (U !== "none") {
+    const _ = un(U);
+    _ && !h.translate && (h.translate = _);
+  }
+  if (!h.transformOrigin) {
+    const _ = M(() => a.current);
+    h.transformOrigin = {
+      x: (_.x - P * p.scaleX - p.x) / (g * p.scaleX),
+      y: (_.y - v * p.scaleY - p.y) / (m * p.scaleY)
+    };
+  }
+  const { transformOrigin: ee } = h, Mt = v * p.scaleY + p.y, It = P * p.scaleX + p.x;
+  if (!h.coordinates && (h.coordinates = {
+    x: It,
+    y: Mt
+  }, b.x !== 1 || b.y !== 1)) {
+    const { scaleX: _, scaleY: A } = w, { x: W, y: te } = ee;
+    h.coordinates.x += (g * _ - g) * W, h.coordinates.y += (m * A - m) * te;
+  }
+  h.dimensions || (h.dimensions = { width: g, height: m }), h.frameTransform || (h.frameTransform = p);
+  const Rt = {
+    x: h.coordinates.x - It,
+    y: h.coordinates.y - Mt
+  }, Wt = {
+    width: (h.dimensions.width * h.frameTransform.scaleX - g * p.scaleX) * ee.x,
+    height: (h.dimensions.height * h.frameTransform.scaleY - m * p.scaleY) * ee.y
+  }, Ye = {
+    x: Rt.x / p.scaleX + Wt.width,
+    y: Rt.y / p.scaleY + Wt.height
+  }, Lt = {
+    left: P + Ye.x,
+    top: v + Ye.y
+  };
+  u.setAttribute(L, "true");
+  const Ft = M(() => o.transform), zt = (t = h.translate) != null ? t : { x: 0, y: 0 }, rr = Ft.x * p.scaleX + zt.x, ir = Ft.y * p.scaleY + zt.y, Nt = hn();
+  S.set(
+    {
+      width: g - Tt,
+      height: m - $t,
+      top: Lt.top + Nt.y,
+      left: Lt.left + Nt.x,
+      translate: `${rr}px ${ir}px 0`,
+      transition: z ? `${z}, translate 0ms linear` : "",
+      scale: k ? `${b.x} ${b.y}` : "",
+      "transform-origin": `${ee.x * 100}% ${ee.y * 100}%`
+    },
+    D
+  ), T && (d.insertAdjacentElement("afterend", T), s?.rootElement && (typeof s.rootElement == "function" ? s.rootElement(l) : s.rootElement).appendChild(d)), Vt(u) && (u.hasAttribute("popover") || u.setAttribute("popover", "manual"), we(u), u.addEventListener("beforetoggle", en));
+  let H, je, Oe;
+  const Kt = ci({
+    placeholder: T,
+    element: d,
+    feedbackElement: u,
+    frameTransform: p,
+    transformOrigin: ee,
+    width: g,
+    height: m,
+    top: v,
+    left: P,
+    widthOffset: Tt,
+    heightOffset: $t,
+    delta: Ye,
+    styles: S,
+    dragOperation: o,
+    getElementMutationObserver: () => H,
+    getSavedCellWidths: () => Oe,
+    setSavedCellWidths: (_) => {
+      Oe = _;
+    }
+  }), Ut = new N(u);
+  M(() => o.shape = Ut);
+  const Be = fn(u), Xt = (_) => {
+    this.manager.actions.stop({ event: _ });
+  }, sr = pn(Be);
+  Xe && Be.addEventListener("resize", Xt), M(() => l.status) === "idle" && requestAnimationFrame(() => l.status = "dragging"), T && (Kt.observe(T), H = ai(
+    d,
+    T,
+    Ct
+  ), je = li(
+    d,
+    T,
+    u
+  ));
+  const Yt = (n = i.dragOperation.source) == null ? void 0 : n.id, or = () => {
+    var _;
+    if (!Xe || Yt == null) return;
+    const A = i.registry.draggables.get(Yt), W = (_ = A?.handle) != null ? _ : A?.element;
+    cn(W) && W.focus();
+  }, He = () => {
+    var _;
+    if (H?.disconnect(), je?.disconnect(), Kt.disconnect(), Be.removeEventListener("resize", Xt), Vt(u) && (u.removeEventListener(
+      "beforetoggle",
+      en
+    ), u.removeAttribute("popover")), u.removeAttribute(L), S.reset(), Oe && ot(d)) {
+      const W = Array.from(d.cells);
+      for (const [te, ne] of W.entries())
+        ne.style.width = (_ = Oe[te]) != null ? _ : "";
+    }
+    l.status = "idle";
+    const A = r.current.translate != null;
+    T && (A || T.parentElement !== u.parentElement) && u.isConnected && T.replaceWith(u), T?.remove();
+  }, ar = s?.dropAnimation, jt = this, lr = Mr(
+    // Update transform on move
+    () => {
+      var _;
+      const { transform: A, status: W } = o;
+      if (!(!A.x && !A.y && !r.current.translate) && W.dragging) {
+        const te = (_ = h.translate) != null ? _ : { x: 0, y: 0 }, ne = {
+          x: A.x / p.scaleX + te.x,
+          y: A.y / p.scaleY + te.y
+        }, Bt = r.current.translate, cr = M(() => o.modifiers), Ve = M(() => {
+          var pe;
+          return (pe = o.shape) == null ? void 0 : pe.current;
+        }), dr = Xe && !sr ? "250ms cubic-bezier(0.25, 1, 0.5, 1)" : "0ms linear";
+        if (S.set(
+          {
+            transition: `${z}, translate ${dr}`,
+            translate: `${ne.x}px ${ne.y}px 0`
+          },
+          D
+        ), H?.takeRecords(), Ve && Ve !== Ut && Bt && !cr.length) {
+          const pe = Ir.delta(ne, Bt);
+          o.shape = mn.from(
+            Ve.boundingRectangle
+          ).translate(
+            pe.x * p.scaleX,
+            pe.y * p.scaleY
+          );
+        } else
+          o.shape = new N(u);
+        r.current.translate = ne;
+      }
+    },
+    // Drop animation
+    function() {
+      if (o.status.dropped) {
+        this.dispose(), l.status = "dropping";
+        const _ = jt.dropAnimation !== void 0 ? jt.dropAnimation : ar;
+        let A = r.current.translate;
+        const W = A != null;
+        if (!A && d !== u && (A = { x: 0, y: 0 }), !A || _ === null) {
+          He();
+          return;
+        }
+        i.renderer.rendering.then(() => {
+          hi({
+            element: d,
+            feedbackElement: u,
+            placeholder: T,
+            translate: A,
+            moved: W,
+            transition: z,
+            alignment: l.alignment,
+            styles: S,
+            animation: _ ?? void 0,
+            getElementMutationObserver: () => H,
+            cleanup: He,
+            restoreFocus: or
+          });
+        });
+      }
+    }
+  );
+  return () => {
+    He(), lr();
+  };
+};
+$(Ee, 4, "overlay", $n, xe, _t);
+Q(Ee, xe);
+xe.configure = pt(xe);
+var fi = xe, ve = !0, pi = !1, Rn, Wn, Ln, Fn, j, wt, St;
+Fn = (Ln = [F], R.Forward), Wn = (Rn = [F], R.Reverse);
+var ke = class {
+  constructor() {
+    E(this, wt, x(j, 8, this, ve)), x(j, 11, this), E(this, St, x(j, 12, this, ve)), x(j, 15, this);
+  }
+  isLocked(e) {
+    return e === R.Idle ? !1 : e == null ? this[R.Forward] === ve && this[R.Reverse] === ve : this[e] === ve;
+  }
+  unlock(e) {
+    e !== R.Idle && (this[e] = pi);
+  }
+};
+j = fe(null);
+wt = /* @__PURE__ */ new WeakMap();
+St = /* @__PURE__ */ new WeakMap();
+$(j, 4, Fn, Ln, ke, wt);
+$(j, 4, Wn, Rn, ke, St);
+Q(j, ke);
+var vi = [R.Forward, R.Reverse], tn = class {
+  constructor() {
+    this.x = new ke(), this.y = new ke();
+  }
+  isLocked() {
+    return this.x.isLocked() && this.y.isLocked();
+  }
+}, mi = class extends ue {
+  constructor(e) {
+    super(e);
+    const t = gn(new tn());
+    let n = null;
+    this.signal = t, J(() => {
+      const { status: r } = e.dragOperation;
+      if (!r.initialized) {
+        n = null, t.value = new tn();
+        return;
+      }
+      const { delta: i } = e.dragOperation.position;
+      if (n) {
+        const s = {
+          x: nn(i.x, n.x),
+          y: nn(i.y, n.y)
+        }, o = t.peek();
+        Wr(() => {
+          for (const a of vn)
+            for (const l of vi)
+              s[a] === l && o[a].unlock(l);
+          t.value = o;
+        });
+      }
+      n = i;
+    });
+  }
+  get current() {
+    return this.signal.peek();
+  }
+};
+function nn(e, t) {
+  return Math.sign(e - t);
+}
+var zn, lt, Ae, Et, Y, ct, Ke = class extends (lt = ft, zn = [F], lt) {
+  constructor(e) {
+    super(e), E(this, Et, x(Ae, 8, this, !1)), x(Ae, 11, this), E(this, Y), E(this, ct, () => {
+      if (!y(this, Y))
+        return;
+      const { element: s, by: o } = y(this, Y);
+      o.y && (s.scrollTop += o.y), o.x && (s.scrollLeft += o.x);
+    }), this.scroll = (s) => {
+      var o;
+      if (this.disabled)
+        return !1;
+      const a = this.getScrollableElements();
+      if (!a)
+        return O(this, Y, void 0), !1;
+      const { position: l } = this.manager.dragOperation, f = l?.current;
+      if (f) {
+        const { by: d } = s ?? {}, c = d ? {
+          x: rn(d.x),
+          y: rn(d.y)
+        } : void 0, h = c ? void 0 : this.scrollIntentTracker.current;
+        if (h?.isLocked())
+          return !1;
+        for (const u of a) {
+          const p = yr(u, d);
+          if (p.x || p.y) {
+            const { speed: w, direction: k } = _r(
+              u,
+              f,
+              c
+            );
+            if (h)
+              for (const C of vn)
+                h[C].isLocked(k[C]) && (w[C] = 0, k[C] = 0);
+            if (k.x || k.y) {
+              const { x: C, y: b } = d ?? k, g = C * w.x, m = b * w.y;
+              if (g || m) {
+                const v = (o = y(this, Y)) == null ? void 0 : o.by;
+                if (this.autoScrolling && v && (v.x && !g || v.y && !m))
+                  continue;
+                return O(this, Y, {
+                  element: u,
+                  by: {
+                    x: g,
+                    y: m
+                  }
+                }), Me.schedule(y(this, ct)), !0;
+              }
+            }
+          }
+        }
+      }
+      return O(this, Y, void 0), !1;
+    };
+    let t = null, n = null;
+    const r = tt(() => {
+      const { position: s, source: o } = e.dragOperation;
+      if (!s)
+        return null;
+      const a = Dr(
+        $e(o?.element),
+        s.current
+      );
+      return a && (t = a), a ?? t;
+    }), i = tt(() => {
+      const s = r.value, { documentElement: o } = Ne(s);
+      if (!s || s === o) {
+        const { target: a } = e.dragOperation, l = a?.element;
+        if (l) {
+          const f = Ht(l, {
+            excludeElement: !1
+          });
+          return n = f, f;
+        }
+      }
+      if (s) {
+        const a = Ht(s, {
+          excludeElement: !1
+        });
+        return this.autoScrolling && n && a.size < n?.size ? n : (n = a, a);
+      }
+      return n = null, null;
+    }, $r);
+    this.getScrollableElements = () => i.value, this.scrollIntentTracker = new mi(e), this.destroy = e.monitor.addEventListener("dragmove", (s) => {
+      this.disabled || s.defaultPrevented || !vt(e.dragOperation.activatorEvent) || !s.by || this.scroll({ by: s.by }) && s.preventDefault();
+    });
+  }
+};
+Ae = fe(lt);
+Et = /* @__PURE__ */ new WeakMap();
+Y = /* @__PURE__ */ new WeakMap();
+ct = /* @__PURE__ */ new WeakMap();
+$(Ae, 4, "autoScrolling", zn, Ke, Et);
+Q(Ae, Ke);
+function rn(e) {
+  return e > 0 ? R.Forward : e < 0 ? R.Reverse : R.Idle;
+}
+var gi = class {
+  constructor(e) {
+    this.scheduler = e, this.pending = !1, this.tasks = /* @__PURE__ */ new Set(), this.resolvers = /* @__PURE__ */ new Set(), this.flush = () => {
+      const { tasks: t, resolvers: n } = this;
+      this.pending = !1, this.tasks = /* @__PURE__ */ new Set(), this.resolvers = /* @__PURE__ */ new Set();
+      for (const r of t)
+        r();
+      for (const r of n)
+        r();
+    };
+  }
+  schedule(e) {
+    return this.tasks.add(e), this.pending || (this.pending = !0, this.scheduler(this.flush)), new Promise((t) => this.resolvers.add(t));
+  }
+}, bi = new gi((e) => {
+  typeof requestAnimationFrame == "function" ? requestAnimationFrame(e) : e();
+}), yi = 10, Nn = class extends ue {
+  constructor(e, t) {
+    super(e);
+    const n = e.registry.plugins.get(Ke);
+    if (!n)
+      throw new Error("AutoScroller plugin depends on Scroller plugin");
+    this.destroy = J(() => {
+      if (this.disabled)
+        return;
+      const { position: r, status: i } = e.dragOperation;
+      if (i.dragging)
+        if (n.scroll()) {
+          n.autoScrolling = !0;
+          const o = setInterval(
+            () => bi.schedule(n.scroll),
+            yi
+          );
+          return () => {
+            clearInterval(o);
+          };
+        } else
+          n.autoScrolling = !1;
+    });
+  }
+}, sn = {
+  capture: !0,
+  passive: !0
+}, ge, _i = class extends ft {
+  constructor(e) {
+    super(e), E(this, ge), this.handleScroll = () => {
+      y(this, ge) == null && O(this, ge, setTimeout(() => {
+        this.manager.collisionObserver.forceUpdate(!1), O(this, ge, void 0);
+      }, 50));
+    };
+    const { dragOperation: t } = this.manager;
+    this.destroy = J(() => {
+      var n, r, i;
+      if (t.status.dragging) {
+        const o = (i = (r = (n = t.source) == null ? void 0 : n.element) == null ? void 0 : r.ownerDocument) != null ? i : document;
+        return o.addEventListener("scroll", this.handleScroll, sn), () => {
+          o.removeEventListener(
+            "scroll",
+            this.handleScroll,
+            sn
+          );
+        };
+      }
+    });
+  }
+};
+ge = /* @__PURE__ */ new WeakMap();
+var wi = class extends ue {
+  constructor(e, t) {
+    super(e, t), this.manager = e, this.destroy = J(() => {
+      var n;
+      const { dragOperation: r } = this.manager, { nonce: i } = (n = this.options) != null ? n : {};
+      if (r.status.initialized) {
+        const s = document.createElement("style");
+        return i && s.setAttribute("nonce", i), s.textContent = "* { user-select: none !important; -webkit-user-select: none !important; }", document.head.appendChild(s), Je(), document.addEventListener("selectionchange", Je, {
+          capture: !0
+        }), () => {
+          document.removeEventListener("selectionchange", Je, {
+            capture: !0
+          }), s.remove();
+        };
+      }
+    });
+  }
+};
+function Je() {
+  var e;
+  (e = document.getSelection()) == null || e.removeAllRanges();
+}
+var be = Object.freeze({
+  offset: 10,
+  keyboardCodes: {
+    start: ["Space", "Enter"],
+    cancel: ["Escape"],
+    end: ["Space", "Enter", "Tab"],
+    up: ["ArrowUp"],
+    down: ["ArrowDown"],
+    left: ["ArrowLeft"],
+    right: ["ArrowRight"]
+  },
+  preventActivation(e, t) {
+    var n;
+    const r = (n = t.handle) != null ? n : t.element;
+    return e.target !== r;
+  }
+}), ie, Fe = class extends Te {
+  constructor(t, n) {
+    super(t), this.manager = t, this.options = n, E(this, ie, []), this.listeners = new ln(), this.handleSourceKeyDown = (r, i, s) => {
+      if (this.disabled || r.defaultPrevented || !le(r.target) || i.disabled)
+        return;
+      const {
+        keyboardCodes: o = be.keyboardCodes,
+        preventActivation: a = be.preventActivation
+      } = s ?? {};
+      o.start.includes(r.code) && this.manager.dragOperation.status.idle && (a?.(r, i) || this.handleStart(r, i, s));
+    };
+  }
+  bind(t, n = this.options) {
+    return J(() => {
+      var i;
+      const s = (i = t.handle) != null ? i : t.element, o = (a) => {
+        vt(a) && this.handleSourceKeyDown(a, t, n);
+      };
+      if (s)
+        return s.addEventListener("keydown", o), () => {
+          s.removeEventListener("keydown", o);
+        };
+    });
+  }
+  handleStart(t, n, r) {
+    const { element: i } = n;
+    if (!i)
+      throw new Error("Source draggable does not have an associated element");
+    t.preventDefault(), t.stopImmediatePropagation(), br(i);
+    const { center: s } = new N(i);
+    if (this.manager.actions.start({
+      event: t,
+      coordinates: {
+        x: s.x,
+        y: s.y
+      },
+      source: n
+    }).signal.aborted) return this.cleanup();
+    this.sideEffects();
+    const a = Ne(i), l = [
+      this.listeners.bind(a, [
+        {
+          type: "keydown",
+          listener: (f) => this.handleKeyDown(f, n, r),
+          options: { capture: !0 }
+        }
+      ])
+    ];
+    y(this, ie).push(...l);
+  }
+  handleKeyDown(t, n, r) {
+    const { keyboardCodes: i = be.keyboardCodes } = r ?? {};
+    if (re(t, [...i.end, ...i.cancel])) {
+      t.preventDefault();
+      const s = re(t, i.cancel);
+      this.handleEnd(t, s);
+      return;
+    }
+    re(t, i.up) ? this.handleMove("up", t) : re(t, i.down) && this.handleMove("down", t), re(t, i.left) ? this.handleMove("left", t) : re(t, i.right) && this.handleMove("right", t);
+  }
+  handleEnd(t, n) {
+    this.manager.actions.stop({
+      event: t,
+      canceled: n
+    }), this.cleanup();
+  }
+  handleMove(t, n) {
+    var r, i;
+    const { shape: s } = this.manager.dragOperation, o = n.shiftKey ? 5 : 1;
+    let a = {
+      x: 0,
+      y: 0
+    }, l = (i = (r = this.options) == null ? void 0 : r.offset) != null ? i : be.offset;
+    if (typeof l == "number" && (l = { x: l, y: l }), !!s) {
+      switch (t) {
+        case "up":
+          a = { x: 0, y: -l.y * o };
+          break;
+        case "down":
+          a = { x: 0, y: l.y * o };
+          break;
+        case "left":
+          a = { x: -l.x * o, y: 0 };
+          break;
+        case "right":
+          a = { x: l.x * o, y: 0 };
+          break;
+      }
+      (a.x || a.y) && (n.preventDefault(), this.manager.actions.move({
+        event: n,
+        by: a
+      }));
+    }
+  }
+  sideEffects() {
+    const t = this.manager.registry.plugins.get(Nn);
+    t?.disabled === !1 && (t.disable(), y(this, ie).push(() => {
+      t.enable();
+    }));
+  }
+  cleanup() {
+    y(this, ie).forEach((t) => t()), O(this, ie, []);
+  }
+  destroy() {
+    this.cleanup(), this.listeners.clear();
+  }
+};
+ie = /* @__PURE__ */ new WeakMap();
+Fe.configure = pt(Fe);
+Fe.defaults = be;
+var Si = Fe;
+function re(e, t) {
+  return t.includes(e.code);
+}
+var V, Ei = class extends an {
+  constructor() {
+    super(...arguments), E(this, V);
+  }
+  onEvent(e) {
+    switch (e.type) {
+      case "pointerdown":
+        O(this, V, ce(e));
+        break;
+      case "pointermove":
+        if (!y(this, V)) return;
+        const { x: t, y: n } = ce(e), r = {
+          x: t - y(this, V).x,
+          y: n - y(this, V).y
+        }, { tolerance: i } = this.options;
+        if (i && nt(r, i)) {
+          this.abort();
+          return;
+        }
+        nt(r, this.options.value) && this.activate(e);
+        break;
+      case "pointerup":
+        this.abort();
+        break;
+    }
+  }
+  abort() {
+    O(this, V, void 0);
+  }
+};
+V = /* @__PURE__ */ new WeakMap();
+var se, q, xi = class extends an {
+  constructor() {
+    super(...arguments), E(this, se), E(this, q);
+  }
+  onEvent(e) {
+    switch (e.type) {
+      case "pointerdown":
+        O(this, q, ce(e)), O(this, se, setTimeout(
+          () => this.activate(e),
+          this.options.value
+        ));
+        break;
+      case "pointermove":
+        if (!y(this, q)) return;
+        const { x: t, y: n } = ce(e), r = {
+          x: t - y(this, q).x,
+          y: n - y(this, q).y
+        };
+        nt(r, this.options.tolerance) && this.abort();
+        break;
+      case "pointerup":
+        this.abort();
+        break;
+    }
+  }
+  abort() {
+    y(this, se) && (clearTimeout(y(this, se)), O(this, q, void 0), O(this, se, void 0));
+  }
+};
+se = /* @__PURE__ */ new WeakMap();
+q = /* @__PURE__ */ new WeakMap();
+var ae = class {
+};
+ae.Delay = xi;
+ae.Distance = Ei;
+var dt = Object.freeze({
+  activationConstraints(e, t) {
+    var n;
+    const { pointerType: r, target: i } = e;
+    if (!(r === "mouse" && le(i) && (t.handle === i || (n = t.handle) != null && n.contains(i))))
+      return r === "touch" ? [
+        new ae.Delay({ value: 250, tolerance: 5 })
+      ] : Sr(i) && !e.defaultPrevented ? [
+        new ae.Delay({ value: 200, tolerance: 0 })
+      ] : [
+        new ae.Delay({ value: 200, tolerance: 10 }),
+        new ae.Distance({ value: 5 })
+      ];
+  },
+  preventActivation(e, t) {
+    var n;
+    const { target: r } = e;
+    return r === t.element || r === t.handle || !le(r) || (n = t.handle) != null && n.contains(r) ? !1 : wr(r);
+  }
+}), oe, ze = class extends Te {
+  constructor(t, n) {
+    super(t), this.manager = t, this.options = n, E(this, oe, /* @__PURE__ */ new Set()), this.listeners = new ln(), this.latest = {
+      event: void 0,
+      coordinates: void 0
+    }, this.handleMove = () => {
+      const { event: r, coordinates: i } = this.latest;
+      !r || !i || this.manager.actions.move({ event: r, to: i });
+    }, this.handleCancel = this.handleCancel.bind(this), this.handlePointerUp = this.handlePointerUp.bind(this), this.handleKeyDown = this.handleKeyDown.bind(this);
+  }
+  activationConstraints(t, n, r = this.options) {
+    const { activationConstraints: i = dt.activationConstraints } = r ?? {};
+    return typeof i == "function" ? i(t, n) : i;
+  }
+  bind(t, n = this.options) {
+    return J(() => {
+      var i;
+      const s = new AbortController(), { signal: o } = s, a = (f) => {
+        Or(f) && this.handlePointerDown(f, t, n);
+      };
+      let l = [(i = t.handle) != null ? i : t.element];
+      n?.activatorElements && (Array.isArray(n.activatorElements) ? l = n.activatorElements : l = n.activatorElements(t));
+      for (const f of l)
+        f && (Oi(f.ownerDocument.defaultView), f.addEventListener("pointerdown", a, { signal: o }));
+      return () => s.abort();
+    });
+  }
+  handlePointerDown(t, n, r) {
+    if (this.disabled || !t.isPrimary || t.button !== 0 || !le(t.target) || n.disabled || Ai(t) || !this.manager.dragOperation.status.idle)
+      return;
+    const { preventActivation: i = dt.preventActivation } = r ?? {};
+    if (i?.(t, n))
+      return;
+    const { target: s } = t, o = cn(s) && s.draggable && s.getAttribute("draggable") === "true", a = Ie(n.element), { x: l, y: f } = ce(t);
+    this.initialCoordinates = {
+      x: l * a.scaleX + a.x,
+      y: f * a.scaleY + a.y
+    };
+    const d = this.activationConstraints(t, n, r);
+    t.sensor = this;
+    const c = new hr(
+      d,
+      (w) => this.handleStart(n, w)
+    );
+    c.signal.onabort = () => this.handleCancel(t), c.onEvent(t), this.controller = c;
+    const h = gr(), u = this.listeners.bind(h, [
+      {
+        type: "pointermove",
+        listener: (w) => this.handlePointerMove(w, n)
+      },
+      {
+        type: "pointerup",
+        listener: this.handlePointerUp,
+        options: {
+          capture: !0
+        }
+      },
+      {
+        type: "pointercancel",
+        listener: this.handleCancel
+      },
+      {
+        // Cancel activation if there is a competing Drag and Drop interaction
+        type: "dragstart",
+        listener: o ? this.handleCancel : Ce,
+        options: {
+          capture: !0
+        }
+      }
+    ]), p = () => {
+      u(), this.initialCoordinates = void 0;
+    };
+    y(this, oe).add(p);
+  }
+  handlePointerMove(t, n) {
+    var r, i;
+    if (((r = this.controller) == null ? void 0 : r.activated) === !1) {
+      (i = this.controller) == null || i.onEvent(t);
+      return;
+    }
+    if (this.manager.dragOperation.status.dragging) {
+      const s = ce(t), o = Ie(n.element);
+      s.x = s.x * o.scaleX + o.x, s.y = s.y * o.scaleY + o.y, t.preventDefault(), t.stopPropagation(), this.latest.event = t, this.latest.coordinates = s, Me.schedule(this.handleMove);
+    }
+  }
+  handlePointerUp(t) {
+    const { status: n } = this.manager.dragOperation;
+    if (!n.idle) {
+      t.preventDefault(), t.stopPropagation();
+      const r = !n.initialized;
+      this.manager.actions.stop({ event: t, canceled: r });
+    }
+    this.cleanup();
+  }
+  handleKeyDown(t) {
+    t.key === "Escape" && (t.preventDefault(), this.handleCancel(t));
+  }
+  handleStart(t, n) {
+    const { manager: r, initialCoordinates: i } = this;
+    if (!i || !r.dragOperation.status.idle || n.defaultPrevented)
+      return;
+    if (r.actions.start({
+      coordinates: i,
+      event: n,
+      source: t
+    }).signal.aborted) return this.cleanup();
+    n.preventDefault();
+    const a = Ne(n.target).body;
+    a.setPointerCapture(n.pointerId);
+    const l = le(n.target) ? [n.target, a] : a, f = this.listeners.bind(l, [
+      {
+        // Prevent scrolling on touch devices
+        type: "touchmove",
+        listener: Ce,
+        options: {
+          passive: !1
+        }
+      },
+      {
+        // Prevent click events
+        type: "click",
+        listener: Ce
+      },
+      {
+        type: "contextmenu",
+        listener: Ce
+      },
+      {
+        type: "keydown",
+        listener: this.handleKeyDown
+      }
+    ]);
+    y(this, oe).add(f);
+  }
+  handleCancel(t) {
+    const { dragOperation: n } = this.manager;
+    n.status.initialized && this.manager.actions.stop({ event: t, canceled: !0 }), this.cleanup();
+  }
+  cleanup() {
+    this.latest = {
+      event: void 0,
+      coordinates: void 0
+    }, y(this, oe).forEach((t) => t()), y(this, oe).clear();
+  }
+  destroy() {
+    this.cleanup(), this.listeners.clear();
+  }
+};
+oe = /* @__PURE__ */ new WeakMap();
+ze.configure = pt(ze);
+ze.defaults = dt;
+var ki = ze;
+function Ai(e) {
+  return "sensor" in e;
+}
+function Ce(e) {
+  e.preventDefault();
+}
+function Di() {
+}
+var on = /* @__PURE__ */ new WeakSet();
+function Oi(e) {
+  !e || on.has(e) || (e.addEventListener("touchmove", Di, {
+    capture: !1,
+    passive: !1
+  }), on.add(e));
+}
+var Qe = {
+  modifiers: [],
+  plugins: [Jr, Nn, Zr, fi, wi],
+  sensors: [ki, Si]
+}, Fi = class extends ur {
+  constructor(e = {}) {
+    const t = qe(e.plugins, Qe.plugins), n = qe(e.sensors, Qe.sensors), r = qe(e.modifiers, Qe.modifiers);
+    super(gt(Se({}, e), {
+      plugins: [_i, Ke, Z, ...t],
+      sensors: n,
+      modifiers: r
+    }));
+  }
+}, Kn, Un, Xn, ut, I, xt, kt, At, Ue = class extends (ut = vr, Xn = [F], Un = [F], Kn = [F], ut) {
+  constructor(e, t) {
+    var n = e, {
+      element: r,
+      effects: i = () => [],
+      handle: s,
+      feedback: o = "default"
+    } = n, a = wn(n, [
+      "element",
+      "effects",
+      "handle",
+      "feedback"
+    ]);
+    super(
+      Se({
+        effects: () => [
+          ...i(),
+          () => {
+            var l, f;
+            const { manager: d } = this;
+            if (!d) return;
+            const h = ((f = (l = this.sensors) == null ? void 0 : l.map(fr)) != null ? f : [
+              ...d.sensors
+            ]).map((u) => {
+              const p = u instanceof Te ? u : d.registry.register(u.plugin), w = u instanceof Te ? void 0 : u.options;
+              return p.bind(this, w);
+            });
+            return function() {
+              h.forEach((p) => p());
+            };
+          }
+        ]
+      }, a),
+      t
+    ), E(this, xt, x(I, 8, this)), x(I, 11, this), E(this, kt, x(I, 12, this)), x(I, 15, this), E(this, At, x(I, 16, this)), x(I, 19, this), this.element = r, this.handle = s, this.feedback = o;
+  }
+};
+I = fe(ut);
+xt = /* @__PURE__ */ new WeakMap();
+kt = /* @__PURE__ */ new WeakMap();
+At = /* @__PURE__ */ new WeakMap();
+$(I, 4, "handle", Xn, Ue, xt);
+$(I, 4, "element", Un, Ue, kt);
+$(I, 4, "feedback", Kn, Ue, At);
+Q(I, Ue);
+var Yn, jn, ht, B, Dt, Ze, Bn, Hn, _e, Ot, Vn = class extends (ht = pr, jn = [F], Yn = [F], ht) {
+  constructor(e, t) {
+    var n = e, { element: r, effects: i = () => [] } = n, s = wn(n, ["element", "effects"]);
+    const { collisionDetector: o = Rr } = s, a = (f) => {
+      const { manager: d, element: c } = this;
+      if (!c || f === null) {
+        this.shape = void 0;
+        return;
+      }
+      if (!d) return;
+      const h = new N(c), u = M(() => this.shape);
+      return h && u?.equals(h) ? u : (this.shape = h, h);
+    }, l = gn(!1);
+    super(
+      gt(Se({}, s), {
+        collisionDetector: o,
+        effects: () => [
+          ...i(),
+          () => {
+            const { element: f, manager: d } = this;
+            if (!d) return;
+            const { dragOperation: c } = d, { source: h } = c;
+            l.value = !!(h && c.status.initialized && f && !this.disabled && this.accepts(h));
+          },
+          () => {
+            const { element: f } = this;
+            if (l.value && f) {
+              const d = new Er(
+                f,
+                a
+              );
+              return () => {
+                d.disconnect(), this.shape = void 0;
+              };
+            }
+          },
+          () => {
+            var f;
+            if ((f = this.manager) != null && f.dragOperation.status.initialized)
+              return () => {
+                this.shape = void 0;
+              };
+          }
+        ]
+      }),
+      t
+    ), E(this, _e), E(this, Dt, x(B, 8, this)), x(B, 11, this), E(this, Ot, x(B, 12, this)), x(B, 15, this), this.element = r, this.refreshShape = () => a();
+  }
+  set element(e) {
+    O(this, _e, e, Hn);
+  }
+  get element() {
+    var e;
+    return (e = this.proxy) != null ? e : y(this, _e, Bn);
+  }
+};
+B = fe(ht);
+Dt = /* @__PURE__ */ new WeakMap();
+_e = /* @__PURE__ */ new WeakSet();
+Ot = /* @__PURE__ */ new WeakMap();
+Ze = $(B, 20, "#element", jn, _e, Dt), Bn = Ze.get, Hn = Ze.set;
+$(B, 4, "proxy", Yn, Vn, Ot);
+Q(B, Vn);
+export {
+  Jr as Accessibility,
+  Nn as AutoScroller,
+  Zr as Cursor,
+  Fi as DragDropManager,
+  Ue as Draggable,
+  Vn as Droppable,
+  fi as Feedback,
+  Si as KeyboardSensor,
+  ae as PointerActivationConstraints,
+  ki as PointerSensor,
+  wi as PreventSelection,
+  _i as ScrollListener,
+  Ke as Scroller,
+  Z as StyleSheetManager,
+  Qe as defaultPreset,
+  qe as resolveCustomizable
+};