@frontify/fondue-components 28.0.0 → 29.0.0

package/dist/fondue-components145.js

@@ -0,0 +1,1355 @@
+import { Droppable as rr, Draggable as ir, descriptor as sr, Sensor as ke, configurator as tt, ActivationController as or, Plugin as nt, CorePlugin as Vt, ActivationConstraint as Gt } from "@dnd-kit/abstract";
+import { resolveCustomizable as mi } from "@dnd-kit/abstract";
+import { DOMRectangle as L, ScrollDirection as I, PositionObserver as ar, Listeners as Jt, isElement as te, isKeyboardEvent as rt, scrollIntoViewIfNeeded as lr, getDocument as it, isPointerEvent as cr, isHTMLElement as Qt, getFrameTransform as xe, getEventCoordinates as ne, getDocuments as dr, scheduler as Zt, isInteractiveElement as ur, isTextInput as hr, getRoot as Oe, canScroll as fr, detectScrollIntent as pr, getScrollableAncestors as Lt, isDocument as vr, isShadowRoot as mr, getComputedStyles as en, parseTranslate as tn, getFixedPositionOffset as nn, Styles as gr, supportsPopover as Ft, showPopover as ve, getWindow as rn, prefersReducedMotion as sn, getElementFromPoint as yr, getFrameElement as zt, cloneElement as br, supportsStyle as Nt, generateUniqueId as _r, ProxiedElements as Kt, getFinalKeyframe as wr, animateTransform as Sr } from "./fondue-components146.js";
+import { computed as Xt, deepEqual as Er, effects as kr, reactive as W, derived as Ne } from "./fondue-components128.js";
+import { Axes as on, Point as xr, Rectangle as an, exceedsDistance as Xe } from "./fondue-components147.js";
+import { defaultCollisionDetection as Or } from "./fondue-components144.js";
+import { untracked as P, signal as ln, effect as Me, batch as Ar } from "./fondue-components131.js";
+var Dr = Object.create, st = Object.defineProperty, Cr = Object.defineProperties, Tr = Object.getOwnPropertyDescriptor, Pr = Object.getOwnPropertyDescriptors, Ae = Object.getOwnPropertySymbols, cn = Object.prototype.hasOwnProperty, dn = Object.prototype.propertyIsEnumerable, un = (e, t) => (t = Symbol[e]) ? t : Symbol.for("Symbol." + e), ie = (e) => {
+  throw TypeError(e);
+}, Ye = (e, t, n) => t in e ? st(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, De = (e, t) => {
+  for (var n in t || (t = {}))
+    cn.call(t, n) && Ye(e, n, t[n]);
+  if (Ae)
+    for (var n of Ae(t))
+      dn.call(t, n) && Ye(e, n, t[n]);
+  return e;
+}, hn = (e, t) => Cr(e, Pr(t)), Yt = (e, t) => st(e, "name", { value: t, configurable: !0 }), fn = (e, t) => {
+  var n = {};
+  for (var r in e)
+    cn.call(e, r) && t.indexOf(r) < 0 && (n[r] = e[r]);
+  if (e != null && Ae)
+    for (var r of Ae(e))
+      t.indexOf(r) < 0 && dn.call(e, r) && (n[r] = e[r]);
+  return n;
+}, se = (e) => {
+  var t;
+  return [, , , Dr((t = e == null ? void 0 : e[un("metadata")]) != null ? t : null)];
+}, pn = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], ue = (e) => e !== void 0 && typeof e != "function" ? ie("Function expected") : e, Mr = (e, t, n, r, i) => ({ kind: pn[e], name: t, metadata: r, addInitializer: (s) => n._ ? ie("Already initialized") : i.push(ue(s || null)) }), j = (e, t) => Ye(t, un("metadata"), e[3]), b = (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;
+}, D = (e, t, n, r, i, s) => {
+  var o, a, l, h, u, d = t & 7, f = !!(t & 8), c = !!(t & 16), p = d > 3 ? e.length + 1 : d ? f ? 1 : 2 : 0, w = pn[d + 5], k = d > 3 && (e[p - 1] = []), C = e[p] || (e[p] = []), y = d && (!c && !f && (i = i.prototype), d < 5 && (d > 3 || !c) && Tr(d < 4 ? i : { get [n]() {
+    return g(this, s);
+  }, set [n](v) {
+    return A(this, s, v);
+  } }, n));
+  d ? c && d < 4 && Yt(s, (d > 2 ? "set " : d > 1 ? "get " : "") + n) : Yt(i, n);
+  for (var E = r.length - 1; E >= 0; E--)
+    h = Mr(d, n, l = {}, e[3], C), d && (h.static = f, h.private = c, u = h.access = { has: c ? (v) => Ir(i, v) : (v) => n in v }, d ^ 3 && (u.get = c ? (v) => (d ^ 1 ? g : B)(v, i, d ^ 4 ? s : y.get) : (v) => v[n]), d > 2 && (u.set = c ? (v, T) => A(v, i, T, d ^ 4 ? s : y.set) : (v, T) => v[n] = T)), a = (0, r[E])(d ? d < 4 ? c ? s : y[w] : d > 4 ? void 0 : { get: y.get, set: y.set } : i, h), l._ = 1, d ^ 4 || a === void 0 ? ue(a) && (d > 4 ? k.unshift(a) : d ? c ? s = a : y[w] = a : i = a) : typeof a != "object" || a === null ? ie("Object expected") : (ue(o = a.get) && (y.get = o), ue(o = a.set) && (y.set = o), ue(o = a.init) && k.unshift(o));
+  return d || j(e, i), y && st(i, n, y), c ? d ^ 4 ? s : y : i;
+}, ot = (e, t, n) => t.has(e) || ie("Cannot " + n), Ir = (e, t) => Object(t) !== t ? ie('Cannot use the "in" operator on this value') : e.has(t), g = (e, t, n) => (ot(e, t, "read from private field"), n ? n.call(e) : t.get(e)), _ = (e, t, n) => t.has(e) ? ie("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), A = (e, t, n, r) => (ot(e, t, "write to private field"), r ? r.call(e, n) : t.set(e, n), n), B = (e, t, n) => (ot(e, t, "access private method"), n), Ce = /* @__PURE__ */ new Map(), vn, mn, gn, yn, Ue, fe, F, at, re, bn, _n, wn, Sn, oe = class extends (Ue = Vt, yn = [W], gn = [Ne], mn = [Ne], vn = [Ne], Ue) {
+  constructor(e) {
+    super(e), b(F, 5, this), _(this, re), _(this, fe, /* @__PURE__ */ new Set()), _(this, at, b(F, 8, this, /* @__PURE__ */ new Set())), b(F, 11, this), this.registerEffect(B(this, re, bn));
+  }
+  /**
+   * 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 g(this, fe).add(e), () => {
+      g(this, fe).delete(e);
+    };
+  }
+  /**
+   * Adds an additional root to track for style injection.
+   * Returns a cleanup function that removes the root.
+   */
+  addRoot(e) {
+    return P(() => {
+      const t = new Set(this.additionalRoots);
+      t.add(e), this.additionalRoots = t;
+    }), () => {
+      P(() => {
+        const t = new Set(this.additionalRoots);
+        t.delete(e), this.additionalRoots = t;
+      });
+    };
+  }
+  get sourceRoot() {
+    var e;
+    const { source: t } = this.manager.dragOperation;
+    return Oe((e = t == null ? void 0 : t.element) != null ? e : null);
+  }
+  get targetRoot() {
+    var e;
+    const { target: t } = this.manager.dragOperation;
+    return Oe((e = t == null ? void 0 : 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();
+  }
+};
+F = se(Ue);
+fe = /* @__PURE__ */ new WeakMap();
+at = /* @__PURE__ */ new WeakMap();
+re = /* @__PURE__ */ new WeakSet();
+bn = function() {
+  const { roots: e } = this, t = [];
+  for (const n of e)
+    for (const r of g(this, fe))
+      t.push(B(this, re, _n).call(this, n, r));
+  return () => {
+    for (const n of t)
+      n();
+  };
+};
+_n = function(e, t) {
+  let n = Ce.get(e);
+  n || (n = /* @__PURE__ */ new Map(), Ce.set(e, n));
+  let r = n.get(t);
+  if (!r) {
+    const s = vr(e) ? B(this, re, wn).call(this, e, n, t) : B(this, re, Sn).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());
+  };
+};
+wn = 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 && Ce.delete(e);
+    }
+  };
+};
+Sn = 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 (mr(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 && Ce.delete(e);
+    }
+  };
+};
+D(F, 4, "additionalRoots", yn, oe, at);
+D(F, 2, "sourceRoot", gn, oe);
+D(F, 2, "targetRoot", mn, oe);
+D(F, 2, "roots", vn, oe);
+j(F, oe);
+var be = "data-dnd-", Be = `${be}dropping`, x = "--dnd-", R = `${be}dragging`, Te = `${be}placeholder`, $r = [
+  R,
+  Te,
+  "popover",
+  "aria-pressed",
+  "aria-grabbing"
+], Rr = ["view-transition-name"], Wr = `
+  :is(:root,:host) [${R}] {
+    position: fixed !important;
+    pointer-events: none !important;
+    touch-action: none;
+    z-index: calc(infinity);
+    will-change: translate;
+    top: var(${x}top, 0px) !important;
+    left: var(${x}left, 0px) !important;
+    right: unset !important;
+    bottom: unset !important;
+    width: var(${x}width, auto);
+    max-width: var(${x}width, auto);
+    height: var(${x}height, auto);
+    max-height: var(${x}height, auto);
+    transition: var(${x}transition) !important;
+  }
+
+  :is(:root,:host) [${Te}] {
+    transition: none;
+  }
+
+  :is(:root,:host) [${Te}='hidden'] {
+    visibility: hidden;
+  }
+
+  [${R}] * {
+    pointer-events: none !important;
+  }
+
+  [${R}]:not([${Be}]) {
+    translate: var(${x}translate) !important;
+  }
+
+  [${R}][style*='${x}scale'] {
+    scale: var(${x}scale) !important;
+    transform-origin: var(${x}transform-origin) !important;
+  }
+
+  @layer dnd-kit {
+    :where([${R}][popover]) {
+      overflow: visible;
+      background: unset;
+      border: unset;
+      margin: unset;
+      padding: unset;
+      color: inherit;
+
+      &:is(input, button) {
+        border: revert;
+        background: revert;
+      }
+    }
+  }
+  [${R}]::backdrop, [${be}overlay]:not([${R}]) {
+    display: none;
+    visibility: hidden;
+  }
+`.replace(/\n+/g, " ").replace(/\s+/g, " ").trim();
+function Lr(e, t = "hidden") {
+  return P(() => {
+    const { element: n, manager: r } = e;
+    if (!n || !r) return;
+    const i = Fr(
+      n,
+      r.registry.droppables
+    ), s = [], o = br(n), { remove: a } = o;
+    return zr(i, o, s), Nr(o, t), o.remove = () => {
+      s.forEach((l) => l()), a.call(o);
+    }, o;
+  });
+}
+function Fr(e, t) {
+  const n = /* @__PURE__ */ new Map();
+  for (const r of t)
+    if (r.element && (e === r.element || e.contains(r.element))) {
+      const i = `${be}${_r("dom-id")}`;
+      r.element.setAttribute(i, ""), n.set(r, i);
+    }
+  return n;
+}
+function zr(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), Kt.set(a, o), n.push(() => {
+      Kt.delete(a), r.proxy = void 0;
+    });
+  }
+}
+function Nr(e, t = "hidden") {
+  e.setAttribute("inert", "true"), e.setAttribute("tab-index", "-1"), e.setAttribute("aria-hidden", "true"), e.setAttribute(Te, t);
+}
+function En(e, t) {
+  return e === t ? !0 : zt(e) === zt(t);
+}
+function Ut(e) {
+  const { target: t } = e;
+  "newState" in e && e.newState === "closed" && te(t) && t.hasAttribute("popover") && requestAnimationFrame(() => ve(t));
+}
+function je(e) {
+  return e.tagName === "TR";
+}
+function Kr(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-") || $r.includes(a))
+        continue;
+      const l = e.getAttribute(a);
+      if (a === "style") {
+        if (Nt(e) && Nt(t)) {
+          const h = e.style;
+          for (const u of Array.from(t.style))
+            h.getPropertyValue(u) === "" && t.style.removeProperty(u);
+          for (const u of Array.from(h)) {
+            if (Rr.includes(u) || u.startsWith(x))
+              continue;
+            const d = h.getPropertyValue(u);
+            t.style.setProperty(u, d);
+          }
+        }
+      } 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 Xr(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), ve(n);
+            return;
+          }
+          if (o.contains(t) && t.previousElementSibling !== e) {
+            t.insertAdjacentElement("beforebegin", e), ve(n);
+            return;
+          }
+        }
+  });
+  return r.observe(e.ownerDocument.body, {
+    childList: !0,
+    subtree: !0
+  }), r;
+}
+function Yr(e) {
+  return new ResizeObserver(() => {
+    var t, n;
+    const r = new L(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 = nn();
+    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
+      },
+      x
+    ), (n = e.getElementMutationObserver()) == null || n.takeRecords(), je(e.element) && je(e.placeholder)) {
+      const l = Array.from(e.element.cells), h = Array.from(e.placeholder.cells);
+      e.getSavedCellWidths() || e.setSavedCellWidths(l.map((u) => u.style.width));
+      for (const [u, d] of l.entries()) {
+        const f = h[u];
+        d.style.width = `${f.getBoundingClientRect().width}px`;
+      }
+    }
+    e.dragOperation.shape = new L(e.feedbackElement);
+  });
+}
+var Ur = 250, Br = "ease";
+function jr(e) {
+  var t, n, r, i;
+  const { animation: s } = e;
+  if (typeof s == "function") {
+    const y = s({
+      element: e.element,
+      feedbackElement: e.feedbackElement,
+      placeholder: e.placeholder,
+      translate: e.translate,
+      moved: e.moved
+    });
+    Promise.resolve(y).then(() => {
+      e.cleanup(), requestAnimationFrame(e.restoreFocus);
+    });
+    return;
+  }
+  const {
+    duration: o = Ur,
+    easing: a = Br
+  } = s ?? {};
+  ve(e.feedbackElement);
+  const [, l] = (t = wr(
+    e.feedbackElement,
+    (y) => "translate" in y
+  )) != null ? t : [];
+  l == null || l.pause();
+  const h = (n = e.placeholder) != null ? n : e.element, u = {
+    frameTransform: En(e.feedbackElement, h) ? null : void 0
+  }, d = new L(e.feedbackElement, u), f = (r = tn(en(e.feedbackElement).translate)) != null ? r : e.translate, c = new L(h, u), p = an.delta(d, c, e.alignment), w = {
+    x: f.x - p.x,
+    y: f.y - p.y
+  }, k = Math.round(d.intrinsicHeight) !== Math.round(c.intrinsicHeight) ? {
+    minHeight: [
+      `${d.intrinsicHeight}px`,
+      `${c.intrinsicHeight}px`
+    ],
+    maxHeight: [
+      `${d.intrinsicHeight}px`,
+      `${c.intrinsicHeight}px`
+    ]
+  } : {}, C = Math.round(d.intrinsicWidth) !== Math.round(c.intrinsicWidth) ? {
+    minWidth: [
+      `${d.intrinsicWidth}px`,
+      `${c.intrinsicWidth}px`
+    ],
+    maxWidth: [
+      `${d.intrinsicWidth}px`,
+      `${c.intrinsicWidth}px`
+    ]
+  } : {};
+  e.styles.set({ transition: e.transition }, x), e.feedbackElement.setAttribute(Be, ""), (i = e.getElementMutationObserver()) == null || i.takeRecords(), Sr({
+    element: e.feedbackElement,
+    keyframes: hn(De(De({}, k), C), {
+      translate: [
+        `${f.x}px ${f.y}px 0`,
+        `${w.x}px ${w.y}px 0`
+      ]
+    }),
+    options: {
+      duration: sn(rn(e.feedbackElement)) ? 0 : e.moved || e.feedbackElement !== e.element ? o : 0,
+      easing: a
+    }
+  }).then(() => {
+    e.feedbackElement.removeAttribute(Be), l == null || l.finish(), e.cleanup(), requestAnimationFrame(e.restoreFocus);
+  });
+}
+var kn, He, me, lt, Ee, xn, On, Pe = class extends (He = nt, kn = [W], He) {
+  constructor(t, n) {
+    super(t, n), _(this, Ee), _(this, lt, b(me, 8, this)), b(me, 11, this), this.state = {
+      initial: {},
+      current: {}
+    };
+    const r = t.registry.plugins.get(
+      oe
+    ), i = r == null ? void 0 : r.register(Wr);
+    if (i) {
+      const s = this.destroy.bind(this);
+      this.destroy = () => {
+        i(), s();
+      };
+    }
+    this.registerEffect(B(this, Ee, xn).bind(this, r)), this.registerEffect(B(this, Ee, On));
+  }
+};
+me = se(He);
+lt = /* @__PURE__ */ new WeakMap();
+Ee = /* @__PURE__ */ new WeakSet();
+xn = function(e) {
+  const { overlay: t } = this;
+  if (!t || !e) return;
+  const n = Oe(t);
+  if (n)
+    return e.addRoot(n);
+};
+On = function() {
+  var e, t, n;
+  const { state: r, manager: i, options: s } = this, { dragOperation: o } = i, { position: a, source: l, status: h } = o;
+  if (h.idle) {
+    r.current = {}, r.initial = {};
+    return;
+  }
+  if (!l) return;
+  const { element: u, feedback: d } = l;
+  if (!u || d === "none" || !h.initialized || h.initializing)
+    return;
+  const { initial: f } = r, c = (e = this.overlay) != null ? e : u, p = xe(c), w = xe(u), k = !En(u, c), C = new L(u, {
+    frameTransform: k ? w : null,
+    ignoreTransforms: !k
+  }), y = {
+    x: w.scaleX / p.scaleX,
+    y: w.scaleY / p.scaleY
+  };
+  let { width: E, height: v, top: T, left: ae } = C;
+  k && (E = E / y.x, v = v / y.y);
+  const le = new gr(c), {
+    transition: _e,
+    translate: yt,
+    boxSizing: Nn,
+    paddingBlockStart: Kn,
+    paddingBlockEnd: Xn,
+    paddingInlineStart: Yn,
+    paddingInlineEnd: Un,
+    borderInlineStartWidth: Bn,
+    borderInlineEndWidth: jn,
+    borderBlockStartWidth: Hn,
+    borderBlockEndWidth: qn
+  } = en(u), bt = d === "clone", _t = Nn === "content-box", wt = _t ? parseInt(Yn) + parseInt(Un) + parseInt(Bn) + parseInt(jn) : 0, St = _t ? parseInt(Kn) + parseInt(Xn) + parseInt(Hn) + parseInt(qn) : 0, O = d !== "move" && !this.overlay ? Lr(l, bt ? "clone" : "hidden") : null, $e = P(
+    () => rt(i.dragOperation.activatorEvent)
+  );
+  if (yt !== "none") {
+    const m = tn(yt);
+    m && !f.translate && (f.translate = m);
+  }
+  if (!f.transformOrigin) {
+    const m = P(() => a.current);
+    f.transformOrigin = {
+      x: (m.x - ae * p.scaleX - p.x) / (E * p.scaleX),
+      y: (m.y - T * p.scaleY - p.y) / (v * p.scaleY)
+    };
+  }
+  const { transformOrigin: H } = f, Et = T * p.scaleY + p.y, kt = ae * p.scaleX + p.x;
+  if (!f.coordinates && (f.coordinates = {
+    x: kt,
+    y: Et
+  }, y.x !== 1 || y.y !== 1)) {
+    const { scaleX: m, scaleY: S } = w, { x: $, y: q } = H;
+    f.coordinates.x += (E * m - E) * $, f.coordinates.y += (v * S - v) * q;
+  }
+  f.dimensions || (f.dimensions = { width: E, height: v }), f.frameTransform || (f.frameTransform = p);
+  const xt = {
+    x: f.coordinates.x - kt,
+    y: f.coordinates.y - Et
+  }, Ot = {
+    width: (f.dimensions.width * f.frameTransform.scaleX - E * p.scaleX) * H.x,
+    height: (f.dimensions.height * f.frameTransform.scaleY - v * p.scaleY) * H.y
+  }, Re = {
+    x: xt.x / p.scaleX + Ot.width,
+    y: xt.y / p.scaleY + Ot.height
+  }, At = {
+    left: ae + Re.x,
+    top: T + Re.y
+  };
+  c.setAttribute(R, "true");
+  const Dt = P(() => o.transform), Ct = (t = f.translate) != null ? t : { x: 0, y: 0 }, Vn = Dt.x * p.scaleX + Ct.x, Gn = Dt.y * p.scaleY + Ct.y, Tt = nn();
+  le.set(
+    {
+      width: E - wt,
+      height: v - St,
+      top: At.top + Tt.y,
+      left: At.left + Tt.x,
+      translate: `${Vn}px ${Gn}px 0`,
+      transition: _e ? `${_e}, translate 0ms linear` : "",
+      scale: k ? `${y.x} ${y.y}` : "",
+      "transform-origin": `${H.x * 100}% ${H.y * 100}%`
+    },
+    x
+  ), O && (u.insertAdjacentElement("afterend", O), s != null && s.rootElement && (typeof s.rootElement == "function" ? s.rootElement(l) : s.rootElement).appendChild(u)), Ft(c) && (c.hasAttribute("popover") || c.setAttribute("popover", "manual"), ve(c), c.addEventListener("beforetoggle", Ut));
+  let X, We, we;
+  const Pt = Yr({
+    placeholder: O,
+    element: u,
+    feedbackElement: c,
+    frameTransform: p,
+    transformOrigin: H,
+    width: E,
+    height: v,
+    top: T,
+    left: ae,
+    widthOffset: wt,
+    heightOffset: St,
+    delta: Re,
+    styles: le,
+    dragOperation: o,
+    getElementMutationObserver: () => X,
+    getSavedCellWidths: () => we,
+    setSavedCellWidths: (m) => {
+      we = m;
+    }
+  }), Mt = new L(c);
+  P(() => o.shape = Mt);
+  const Le = rn(c), It = (m) => {
+    this.manager.actions.stop({ event: m });
+  }, Jn = sn(Le);
+  $e && Le.addEventListener("resize", It), P(() => l.status) === "idle" && requestAnimationFrame(() => l.status = "dragging"), O && (Pt.observe(O), X = Kr(
+    u,
+    O,
+    bt
+  ), We = Xr(
+    u,
+    O,
+    c
+  ));
+  const $t = (n = i.dragOperation.source) == null ? void 0 : n.id, Qn = () => {
+    var m;
+    if (!$e || $t == null) return;
+    const S = i.registry.draggables.get($t), $ = (m = S == null ? void 0 : S.handle) != null ? m : S == null ? void 0 : S.element;
+    Qt($) && $.focus();
+  }, Fe = () => {
+    var m;
+    if (X == null || X.disconnect(), We == null || We.disconnect(), Pt.disconnect(), Le.removeEventListener("resize", It), Ft(c) && (c.removeEventListener(
+      "beforetoggle",
+      Ut
+    ), c.removeAttribute("popover")), c.removeAttribute(R), le.reset(), we && je(u)) {
+      const $ = Array.from(u.cells);
+      for (const [q, V] of $.entries())
+        V.style.width = (m = we[q]) != null ? m : "";
+    }
+    l.status = "idle";
+    const S = r.current.translate != null;
+    O && (S || O.parentElement !== c.parentElement) && c.isConnected && O.replaceWith(c), O == null || O.remove();
+  }, Zn = s == null ? void 0 : s.dropAnimation, Rt = this, er = kr(
+    // Update transform on move
+    () => {
+      var m;
+      const { transform: S, status: $ } = o;
+      if (!(!S.x && !S.y && !r.current.translate) && $.dragging) {
+        const q = (m = f.translate) != null ? m : { x: 0, y: 0 }, V = {
+          x: S.x / p.scaleX + q.x,
+          y: S.y / p.scaleY + q.y
+        }, Wt = r.current.translate, tr = P(() => o.modifiers), ze = P(() => {
+          var ce;
+          return (ce = o.shape) == null ? void 0 : ce.current;
+        }), nr = $e && !Jn ? "250ms cubic-bezier(0.25, 1, 0.5, 1)" : "0ms linear";
+        if (le.set(
+          {
+            transition: `${_e}, translate ${nr}`,
+            translate: `${V.x}px ${V.y}px 0`
+          },
+          x
+        ), X == null || X.takeRecords(), ze && ze !== Mt && Wt && !tr.length) {
+          const ce = xr.delta(V, Wt);
+          o.shape = an.from(
+            ze.boundingRectangle
+          ).translate(
+            ce.x * p.scaleX,
+            ce.y * p.scaleY
+          );
+        } else
+          o.shape = new L(c);
+        r.current.translate = V;
+      }
+    },
+    // Drop animation
+    function() {
+      if (o.status.dropped) {
+        this.dispose(), l.status = "dropping";
+        const m = Rt.dropAnimation !== void 0 ? Rt.dropAnimation : Zn;
+        let S = r.current.translate;
+        const $ = S != null;
+        if (!S && u !== c && (S = { x: 0, y: 0 }), !S || m === null) {
+          Fe();
+          return;
+        }
+        i.renderer.rendering.then(() => {
+          jr({
+            element: u,
+            feedbackElement: c,
+            placeholder: O,
+            translate: S,
+            moved: $,
+            transition: _e,
+            alignment: l.alignment,
+            styles: le,
+            animation: m ?? void 0,
+            getElementMutationObserver: () => X,
+            cleanup: Fe,
+            restoreFocus: Qn
+          });
+        });
+      }
+    }
+  );
+  return () => {
+    Fe(), er();
+  };
+};
+D(me, 4, "overlay", kn, Pe, lt);
+j(me, Pe);
+Pe.configure = tt(Pe);
+var de = !0, Hr = !1, An, Dn, Cn, Tn, N, ct, dt;
+Tn = (Cn = [W], I.Forward), Dn = (An = [W], I.Reverse);
+var ge = class {
+  constructor() {
+    _(this, ct, b(N, 8, this, de)), b(N, 11, this), _(this, dt, b(N, 12, this, de)), b(N, 15, this);
+  }
+  isLocked(e) {
+    return e === I.Idle ? !1 : e == null ? this[I.Forward] === de && this[I.Reverse] === de : this[e] === de;
+  }
+  unlock(e) {
+    e !== I.Idle && (this[e] = Hr);
+  }
+};
+N = se(null);
+ct = /* @__PURE__ */ new WeakMap();
+dt = /* @__PURE__ */ new WeakMap();
+D(N, 4, Tn, Cn, ge, ct);
+D(N, 4, Dn, An, ge, dt);
+j(N, ge);
+var qr = [I.Forward, I.Reverse], Bt = class {
+  constructor() {
+    this.x = new ge(), this.y = new ge();
+  }
+  isLocked() {
+    return this.x.isLocked() && this.y.isLocked();
+  }
+}, Vr = class extends nt {
+  constructor(e) {
+    super(e);
+    const t = ln(new Bt());
+    let n = null;
+    this.signal = t, Me(() => {
+      const { status: r } = e.dragOperation;
+      if (!r.initialized) {
+        n = null, t.value = new Bt();
+        return;
+      }
+      const { delta: i } = e.dragOperation.position;
+      if (n) {
+        const s = {
+          x: jt(i.x, n.x),
+          y: jt(i.y, n.y)
+        }, o = t.peek();
+        Ar(() => {
+          for (const a of on)
+            for (const l of qr)
+              s[a] === l && o[a].unlock(l);
+          t.value = o;
+        });
+      }
+      n = i;
+    });
+  }
+  get current() {
+    return this.signal.peek();
+  }
+};
+function jt(e, t) {
+  return Math.sign(e - t);
+}
+var Pn, qe, ye, ut, z, Ve, ht = class extends (qe = Vt, Pn = [W], qe) {
+  constructor(e) {
+    super(e), _(this, ut, b(ye, 8, this, !1)), b(ye, 11, this), _(this, z), _(this, Ve, () => {
+      if (!g(this, z))
+        return;
+      const { element: s, by: o } = g(this, z);
+      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 A(this, z, void 0), !1;
+      const { position: l } = this.manager.dragOperation, h = l == null ? void 0 : l.current;
+      if (h) {
+        const { by: u } = s ?? {}, d = u ? {
+          x: Ht(u.x),
+          y: Ht(u.y)
+        } : void 0, f = d ? void 0 : this.scrollIntentTracker.current;
+        if (f != null && f.isLocked())
+          return !1;
+        for (const c of a) {
+          const p = fr(c, u);
+          if (p.x || p.y) {
+            const { speed: w, direction: k } = pr(
+              c,
+              h,
+              d
+            );
+            if (f)
+              for (const C of on)
+                f[C].isLocked(k[C]) && (w[C] = 0, k[C] = 0);
+            if (k.x || k.y) {
+              const { x: C, y } = u ?? k, E = C * w.x, v = y * w.y;
+              if (E || v) {
+                const T = (o = g(this, z)) == null ? void 0 : o.by;
+                if (this.autoScrolling && T && (T.x && !E || T.y && !v))
+                  continue;
+                return A(this, z, {
+                  element: c,
+                  by: {
+                    x: E,
+                    y: v
+                  }
+                }), Zt.schedule(g(this, Ve)), !0;
+              }
+            }
+          }
+        }
+      }
+      return A(this, z, void 0), !1;
+    };
+    let t = null, n = null;
+    const r = Xt(() => {
+      const { position: s, source: o } = e.dragOperation;
+      if (!s)
+        return null;
+      const a = yr(
+        Oe(o == null ? void 0 : o.element),
+        s.current
+      );
+      return a && (t = a), a ?? t;
+    }), i = Xt(() => {
+      const s = r.value, { documentElement: o } = it(s);
+      if (!s || s === o) {
+        const { target: a } = e.dragOperation, l = a == null ? void 0 : a.element;
+        if (l) {
+          const h = Lt(l, {
+            excludeElement: !1
+          });
+          return n = h, h;
+        }
+      }
+      if (s) {
+        const a = Lt(s, {
+          excludeElement: !1
+        });
+        return this.autoScrolling && n && a.size < (n == null ? void 0 : n.size) ? n : (n = a, a);
+      }
+      return n = null, null;
+    }, Er);
+    this.getScrollableElements = () => i.value, this.scrollIntentTracker = new Vr(e), this.destroy = e.monitor.addEventListener("dragmove", (s) => {
+      this.disabled || s.defaultPrevented || !rt(e.dragOperation.activatorEvent) || !s.by || this.scroll({ by: s.by }) && s.preventDefault();
+    });
+  }
+};
+ye = se(qe);
+ut = /* @__PURE__ */ new WeakMap();
+z = /* @__PURE__ */ new WeakMap();
+Ve = /* @__PURE__ */ new WeakMap();
+D(ye, 4, "autoScrolling", Pn, ht, ut);
+j(ye, ht);
+function Ht(e) {
+  return e > 0 ? I.Forward : e < 0 ? I.Reverse : I.Idle;
+}
+var Gr = 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));
+  }
+}, Jr = new Gr((e) => {
+  typeof requestAnimationFrame == "function" ? requestAnimationFrame(e) : e();
+}), Qr = 10, Zr = class extends nt {
+  constructor(e, t) {
+    super(e);
+    const n = e.registry.plugins.get(ht);
+    if (!n)
+      throw new Error("AutoScroller plugin depends on Scroller plugin");
+    this.destroy = Me(() => {
+      if (this.disabled)
+        return;
+      const { position: r, status: i } = e.dragOperation;
+      if (i.dragging)
+        if (n.scroll()) {
+          n.autoScrolling = !0;
+          const o = setInterval(
+            () => Jr.schedule(n.scroll),
+            Qr
+          );
+          return () => {
+            clearInterval(o);
+          };
+        } else
+          n.autoScrolling = !1;
+    });
+  }
+}, he = 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;
+  }
+}), J, Ge = class extends ke {
+  constructor(t, n) {
+    super(t), this.manager = t, this.options = n, _(this, J, []), this.listeners = new Jt(), this.handleSourceKeyDown = (r, i, s) => {
+      if (this.disabled || r.defaultPrevented || !te(r.target) || i.disabled)
+        return;
+      const {
+        keyboardCodes: o = he.keyboardCodes,
+        preventActivation: a = he.preventActivation
+      } = s ?? {};
+      o.start.includes(r.code) && this.manager.dragOperation.status.idle && (a != null && a(r, i) || this.handleStart(r, i, s));
+    };
+  }
+  bind(t, n = this.options) {
+    return Me(() => {
+      var i;
+      const s = (i = t.handle) != null ? i : t.element, o = (a) => {
+        rt(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(), lr(i);
+    const { center: s } = new L(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 = it(i), l = [
+      this.listeners.bind(a, [
+        {
+          type: "keydown",
+          listener: (h) => this.handleKeyDown(h, n, r),
+          options: { capture: !0 }
+        }
+      ])
+    ];
+    g(this, J).push(...l);
+  }
+  handleKeyDown(t, n, r) {
+    const { keyboardCodes: i = he.keyboardCodes } = r ?? {};
+    if (G(t, [...i.end, ...i.cancel])) {
+      t.preventDefault();
+      const s = G(t, i.cancel);
+      this.handleEnd(t, s);
+      return;
+    }
+    G(t, i.up) ? this.handleMove("up", t) : G(t, i.down) && this.handleMove("down", t), G(t, i.left) ? this.handleMove("left", t) : G(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 : he.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(Zr);
+    (t == null ? void 0 : t.disabled) === !1 && (t.disable(), g(this, J).push(() => {
+      t.enable();
+    }));
+  }
+  cleanup() {
+    g(this, J).forEach((t) => t()), A(this, J, []);
+  }
+  destroy() {
+    this.cleanup(), this.listeners.clear();
+  }
+};
+J = /* @__PURE__ */ new WeakMap();
+Ge.configure = tt(Ge);
+Ge.defaults = he;
+function G(e, t) {
+  return t.includes(e.code);
+}
+var Y, ei = class extends Gt {
+  constructor() {
+    super(...arguments), _(this, Y);
+  }
+  onEvent(e) {
+    switch (e.type) {
+      case "pointerdown":
+        A(this, Y, ne(e));
+        break;
+      case "pointermove":
+        if (!g(this, Y)) return;
+        const { x: t, y: n } = ne(e), r = {
+          x: t - g(this, Y).x,
+          y: n - g(this, Y).y
+        }, { tolerance: i } = this.options;
+        if (i && Xe(r, i)) {
+          this.abort();
+          return;
+        }
+        Xe(r, this.options.value) && this.activate(e);
+        break;
+      case "pointerup":
+        this.abort();
+        break;
+    }
+  }
+  abort() {
+    A(this, Y, void 0);
+  }
+};
+Y = /* @__PURE__ */ new WeakMap();
+var Q, U, ti = class extends Gt {
+  constructor() {
+    super(...arguments), _(this, Q), _(this, U);
+  }
+  onEvent(e) {
+    switch (e.type) {
+      case "pointerdown":
+        A(this, U, ne(e)), A(this, Q, setTimeout(
+          () => this.activate(e),
+          this.options.value
+        ));
+        break;
+      case "pointermove":
+        if (!g(this, U)) return;
+        const { x: t, y: n } = ne(e), r = {
+          x: t - g(this, U).x,
+          y: n - g(this, U).y
+        };
+        Xe(r, this.options.tolerance) && this.abort();
+        break;
+      case "pointerup":
+        this.abort();
+        break;
+    }
+  }
+  abort() {
+    g(this, Q) && (clearTimeout(g(this, Q)), A(this, U, void 0), A(this, Q, void 0));
+  }
+};
+Q = /* @__PURE__ */ new WeakMap();
+U = /* @__PURE__ */ new WeakMap();
+var ee = class {
+};
+ee.Delay = ti;
+ee.Distance = ei;
+var Je = Object.freeze({
+  activationConstraints(e, t) {
+    var n;
+    const { pointerType: r, target: i } = e;
+    if (!(r === "mouse" && te(i) && (t.handle === i || (n = t.handle) != null && n.contains(i))))
+      return r === "touch" ? [
+        new ee.Delay({ value: 250, tolerance: 5 })
+      ] : hr(i) && !e.defaultPrevented ? [
+        new ee.Delay({ value: 200, tolerance: 0 })
+      ] : [
+        new ee.Delay({ value: 200, tolerance: 10 }),
+        new ee.Distance({ value: 5 })
+      ];
+  },
+  preventActivation(e, t) {
+    var n;
+    const { target: r } = e;
+    return r === t.element || r === t.handle || !te(r) || (n = t.handle) != null && n.contains(r) ? !1 : ur(r);
+  }
+}), Z, Qe = class extends ke {
+  constructor(t, n) {
+    super(t), this.manager = t, this.options = n, _(this, Z, /* @__PURE__ */ new Set()), this.listeners = new Jt(), 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 = Je.activationConstraints } = r ?? {};
+    return typeof i == "function" ? i(t, n) : i;
+  }
+  bind(t, n = this.options) {
+    return Me(() => {
+      var i;
+      const s = new AbortController(), { signal: o } = s, a = (h) => {
+        cr(h) && this.handlePointerDown(h, t, n);
+      };
+      let l = [(i = t.handle) != null ? i : t.element];
+      n != null && n.activatorElements && (Array.isArray(n.activatorElements) ? l = n.activatorElements : l = n.activatorElements(t));
+      for (const h of l)
+        h && (ii(h.ownerDocument.defaultView), h.addEventListener("pointerdown", a, { signal: o }));
+      return () => s.abort();
+    });
+  }
+  handlePointerDown(t, n, r) {
+    if (this.disabled || !t.isPrimary || t.button !== 0 || !te(t.target) || n.disabled || ni(t) || !this.manager.dragOperation.status.idle)
+      return;
+    const { preventActivation: i = Je.preventActivation } = r ?? {};
+    if (i != null && i(t, n))
+      return;
+    const { target: s } = t, o = Qt(s) && s.draggable && s.getAttribute("draggable") === "true", a = xe(n.element), { x: l, y: h } = ne(t);
+    this.initialCoordinates = {
+      x: l * a.scaleX + a.x,
+      y: h * a.scaleY + a.y
+    };
+    const u = this.activationConstraints(t, n, r);
+    t.sensor = this;
+    const d = new or(
+      u,
+      (w) => this.handleStart(n, w)
+    );
+    d.signal.onabort = () => this.handleCancel(t), d.onEvent(t), this.controller = d;
+    const f = dr(), c = this.listeners.bind(f, [
+      {
+        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 : Se,
+        options: {
+          capture: !0
+        }
+      }
+    ]), p = () => {
+      c(), this.initialCoordinates = void 0;
+    };
+    g(this, Z).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 = ne(t), o = xe(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, Zt.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 = it(n.target).body;
+    a.setPointerCapture(n.pointerId);
+    const l = te(n.target) ? [n.target, a] : a, h = this.listeners.bind(l, [
+      {
+        // Prevent scrolling on touch devices
+        type: "touchmove",
+        listener: Se,
+        options: {
+          passive: !1
+        }
+      },
+      {
+        // Prevent click events
+        type: "click",
+        listener: Se
+      },
+      {
+        type: "contextmenu",
+        listener: Se
+      },
+      {
+        type: "keydown",
+        listener: this.handleKeyDown
+      }
+    ]);
+    g(this, Z).add(h);
+  }
+  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
+    }, g(this, Z).forEach((t) => t()), g(this, Z).clear();
+  }
+  destroy() {
+    this.cleanup(), this.listeners.clear();
+  }
+};
+Z = /* @__PURE__ */ new WeakMap();
+Qe.configure = tt(Qe);
+Qe.defaults = Je;
+function ni(e) {
+  return "sensor" in e;
+}
+function Se(e) {
+  e.preventDefault();
+}
+function ri() {
+}
+var qt = /* @__PURE__ */ new WeakSet();
+function ii(e) {
+  !e || qt.has(e) || (e.addEventListener("touchmove", ri, {
+    capture: !1,
+    passive: !1
+  }), qt.add(e));
+}
+var Mn, In, $n, Ze, M, ft, pt, vt, Ie = class extends (Ze = ir, $n = [W], In = [W], Mn = [W], Ze) {
+  constructor(e, t) {
+    var n = e, {
+      element: r,
+      effects: i = () => [],
+      handle: s,
+      feedback: o = "default"
+    } = n, a = fn(n, [
+      "element",
+      "effects",
+      "handle",
+      "feedback"
+    ]);
+    super(
+      De({
+        effects: () => [
+          ...i(),
+          () => {
+            var l, h;
+            const { manager: u } = this;
+            if (!u) return;
+            const f = ((h = (l = this.sensors) == null ? void 0 : l.map(sr)) != null ? h : [
+              ...u.sensors
+            ]).map((c) => {
+              const p = c instanceof ke ? c : u.registry.register(c.plugin), w = c instanceof ke ? void 0 : c.options;
+              return p.bind(this, w);
+            });
+            return function() {
+              f.forEach((p) => p());
+            };
+          }
+        ]
+      }, a),
+      t
+    ), _(this, ft, b(M, 8, this)), b(M, 11, this), _(this, pt, b(M, 12, this)), b(M, 15, this), _(this, vt, b(M, 16, this)), b(M, 19, this), this.element = r, this.handle = s, this.feedback = o;
+  }
+};
+M = se(Ze);
+ft = /* @__PURE__ */ new WeakMap();
+pt = /* @__PURE__ */ new WeakMap();
+vt = /* @__PURE__ */ new WeakMap();
+D(M, 4, "handle", $n, Ie, ft);
+D(M, 4, "element", In, Ie, pt);
+D(M, 4, "feedback", Mn, Ie, vt);
+j(M, Ie);
+var Rn, Wn, et, K, mt, Ke, Ln, Fn, pe, gt, zn = class extends (et = rr, Wn = [W], Rn = [W], et) {
+  constructor(e, t) {
+    var n = e, { element: r, effects: i = () => [] } = n, s = fn(n, ["element", "effects"]);
+    const { collisionDetector: o = Or } = s, a = (h) => {
+      const { manager: u, element: d } = this;
+      if (!d || h === null) {
+        this.shape = void 0;
+        return;
+      }
+      if (!u) return;
+      const f = new L(d), c = P(() => this.shape);
+      return f && (c != null && c.equals(f)) ? c : (this.shape = f, f);
+    }, l = ln(!1);
+    super(
+      hn(De({}, s), {
+        collisionDetector: o,
+        effects: () => [
+          ...i(),
+          () => {
+            const { element: h, manager: u } = this;
+            if (!u) return;
+            const { dragOperation: d } = u, { source: f } = d;
+            l.value = !!(f && d.status.initialized && h && !this.disabled && this.accepts(f));
+          },
+          () => {
+            const { element: h } = this;
+            if (l.value && h) {
+              const u = new ar(
+                h,
+                a
+              );
+              return () => {
+                u.disconnect(), this.shape = void 0;
+              };
+            }
+          },
+          () => {
+            var h;
+            if ((h = this.manager) != null && h.dragOperation.status.initialized)
+              return () => {
+                this.shape = void 0;
+              };
+          }
+        ]
+      }),
+      t
+    ), _(this, pe), _(this, mt, b(K, 8, this)), b(K, 11, this), _(this, gt, b(K, 12, this)), b(K, 15, this), this.element = r, this.refreshShape = () => a();
+  }
+  set element(e) {
+    A(this, pe, e, Fn);
+  }
+  get element() {
+    var e;
+    return (e = this.proxy) != null ? e : g(this, pe, Ln);
+  }
+};
+K = se(et);
+mt = /* @__PURE__ */ new WeakMap();
+pe = /* @__PURE__ */ new WeakSet();
+gt = /* @__PURE__ */ new WeakMap();
+Ke = D(K, 20, "#element", Wn, pe, mt), Ln = Ke.get, Fn = Ke.set;
+D(K, 4, "proxy", Rn, zn, gt);
+j(K, zn);
+export {
+  Zr as AutoScroller,
+  Ie as Draggable,
+  zn as Droppable,
+  ee as PointerActivationConstraints,
+  ht as Scroller,
+  oe as StyleSheetManager,
+  mi as resolveCustomizable
+};
+//# sourceMappingURL=fondue-components145.js.map