import {
  computed,
  createCommentVNode,
  createElementBlock,
  createVNode,
  inject,
  nextTick,
  normalizeClass,
  normalizeStyle,
  onBeforeMount,
  onBeforeUnmount,
  onMounted,
  openBlock,
  provide,
  reactive,
  renderSlot,
  unref,
  vShow,
  watch,
  withDirectives
} from "./chunk-EMDJYNZL.js";
import "./chunk-ZS7NZCD4.js";

// node_modules/vue-grid-layout-v3/dist/vue-grid-layout-v3.js
import "E:/AiProject/claude-web/node_modules/vue-grid-layout-v3/dist/index.css";
var q = {
  init: yi,
  document: null,
  DocumentFragment: null,
  SVGElement: null,
  SVGSVGElement: null,
  SVGElementInstance: null,
  Element: null,
  HTMLElement: null,
  Event: null,
  Touch: null,
  PointerEvent: null
};
function Pt() {
}
function yi(e) {
  const t = e;
  q.document = t.document, q.DocumentFragment = t.DocumentFragment || Pt, q.SVGElement = t.SVGElement || Pt, q.SVGSVGElement = t.SVGSVGElement || Pt, q.SVGElementInstance = t.SVGElementInstance || Pt, q.Element = t.Element || Pt, q.HTMLElement = t.HTMLElement || q.Element, q.Event = t.Event, q.Touch = t.Touch || Pt, q.PointerEvent = t.PointerEvent || t.MSPointerEvent;
}
var yn = (e) => !!(e && e.Window) && e instanceof e.Window;
var bn;
var pt;
function xn(e) {
  bn = e;
  const t = e.document.createTextNode("");
  t.ownerDocument !== e.document && typeof e.wrap == "function" && e.wrap(t) === t && (e = e.wrap(e)), pt = e;
}
typeof window < "u" && window && xn(window);
function It(e) {
  return yn(e) ? e : (e.ownerDocument || e).defaultView || pt.window;
}
var bi = (e) => e === pt || yn(e);
var xi = (e) => ie(e) && e.nodeType === 11;
var ie = (e) => !!e && typeof e == "object";
var wn = (e) => typeof e == "function";
var wi = (e) => typeof e == "number";
var Si = (e) => typeof e == "boolean";
var Ei = (e) => typeof e == "string";
var zi = (e) => {
  if (!e || typeof e != "object")
    return false;
  const t = It(e) || pt;
  return /object|function/.test(typeof Element) ? e instanceof Element || e instanceof t.Element : e.nodeType === 1 && typeof e.nodeName == "string";
};
var Ii = (e) => ie(e) && !!e.constructor && /function Object\b/.test(e.constructor.toString());
var Ti = (e) => ie(e) && typeof e.length < "u" && wn(e.splice);
var p = {
  window: bi,
  docFrag: xi,
  object: ie,
  func: wn,
  number: wi,
  bool: Si,
  string: Ei,
  element: zi,
  plainObject: Ii,
  array: Ti
};
var G = {
  init: Di,
  supportsTouch: null,
  supportsPointerEvent: null,
  isIOS7: null,
  isIOS: null,
  isIe9: null,
  isOperaMobile: null,
  prefixedMatchesSelector: null,
  pEventTypes: null,
  wheelEvent: null
};
function Di(e) {
  const t = q.Element, n = e.navigator || {};
  G.supportsTouch = "ontouchstart" in e || p.func(e.DocumentTouch) && q.document instanceof e.DocumentTouch, G.supportsPointerEvent = n.pointerEnabled !== false && !!q.PointerEvent, G.isIOS = /iP(hone|od|ad)/.test(n.platform), G.isIOS7 = /iP(hone|od|ad)/.test(n.platform) && /OS 7[^\d]/.test(n.appVersion), G.isIe9 = /MSIE 9/.test(n.userAgent), G.isOperaMobile = n.appName === "Opera" && G.supportsTouch && /Presto/.test(n.userAgent), G.prefixedMatchesSelector = "matches" in t.prototype ? "matches" : "webkitMatchesSelector" in t.prototype ? "webkitMatchesSelector" : "mozMatchesSelector" in t.prototype ? "mozMatchesSelector" : "oMatchesSelector" in t.prototype ? "oMatchesSelector" : "msMatchesSelector", G.pEventTypes = G.supportsPointerEvent ? q.PointerEvent === e.MSPointerEvent ? {
    up: "MSPointerUp",
    down: "MSPointerDown",
    over: "mouseover",
    out: "mouseout",
    move: "MSPointerMove",
    cancel: "MSPointerCancel"
  } : {
    up: "pointerup",
    down: "pointerdown",
    over: "pointerover",
    out: "pointerout",
    move: "pointermove",
    cancel: "pointercancel"
  } : null, G.wheelEvent = q.document && "onmousewheel" in q.document ? "mousewheel" : "wheel";
}
var Sn = (e, t) => {
  for (const n of t)
    e.push(n);
  return e;
};
var En = (e) => Sn([], e);
var re = (e, t) => {
  for (let n = 0; n < e.length; n++)
    if (t(e[n], n, e))
      return n;
  return -1;
};
var Jt = (e, t) => e[re(e, t)];
function Rt(e) {
  const t = {};
  for (const n in e) {
    const i = e[n];
    p.plainObject(i) ? t[n] = Rt(i) : p.array(i) ? t[n] = En(i) : t[n] = i;
  }
  return t;
}
function I(e, t) {
  for (const i in t)
    e[i] = t[i];
  return e;
}
var Be = 0;
var ct;
var wt;
function Mi(e) {
  if (ct = e.requestAnimationFrame, wt = e.cancelAnimationFrame, !ct) {
    const t = ["ms", "moz", "webkit", "o"];
    for (const n of t)
      ct = e[`${n}RequestAnimationFrame`], wt = e[`${n}CancelAnimationFrame`] || e[`${n}CancelRequestAnimationFrame`];
  }
  ct = ct && ct.bind(e), wt = wt && wt.bind(e), ct || (ct = (t) => {
    const n = Date.now(), i = Math.max(0, 16 - (n - Be)), o = e.setTimeout(() => {
      t(n + i);
    }, i);
    return Be = n + i, o;
  }, wt = (t) => clearTimeout(t));
}
var Ot = {
  request: (e) => ct(e),
  cancel: (e) => wt(e),
  init: Mi
};
function Et(e, t) {
  let n = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : (o) => true, i = arguments.length > 3 ? arguments[3] : void 0;
  if (i = i || {}, p.string(e) && e.search(" ") !== -1 && (e = Ne(e)), p.array(e))
    return e.forEach((o) => Et(o, t, n, i)), i;
  if (p.object(e) && (t = e, e = ""), p.func(t) && n(e))
    i[e] = i[e] || [], i[e].push(t);
  else if (p.array(t))
    for (const o of t)
      Et(e, o, n, i);
  else if (p.object(t))
    for (const o in t) {
      const s = Ne(o).map((a) => `${e}${a}`);
      Et(s, t[o], n, i);
    }
  return i;
}
function Ne(e) {
  return e.trim().split(/ +/);
}
function Fe(e, t) {
  for (const n of t) {
    if (e.immediatePropagationStopped)
      break;
    n(e);
  }
}
var zn = class {
  constructor(t) {
    this.options = void 0, this.types = {}, this.propagationStopped = false, this.immediatePropagationStopped = false, this.global = void 0, this.options = I({}, t || {});
  }
  fire(t) {
    let n;
    const i = this.global;
    (n = this.types[t.type]) && Fe(t, n), !t.propagationStopped && i && (n = i[t.type]) && Fe(t, n);
  }
  on(t, n) {
    const i = Et(t, n);
    for (t in i)
      this.types[t] = Sn(this.types[t] || [], i[t]);
  }
  off(t, n) {
    const i = Et(t, n);
    for (t in i) {
      const o = this.types[t];
      if (!(!o || !o.length))
        for (const s of i[t]) {
          const a = o.indexOf(s);
          a !== -1 && o.splice(a, 1);
        }
    }
  }
  getRect(t) {
    return null;
  }
};
function zt(e, t) {
  if (e.contains)
    return e.contains(t);
  for (; t; ) {
    if (t === e)
      return true;
    t = t.parentNode;
  }
  return false;
}
function In(e, t) {
  for (; p.element(e); ) {
    if (Tt(e, t))
      return e;
    e = gt(e);
  }
  return null;
}
function gt(e) {
  let t = e.parentNode;
  if (p.docFrag(t)) {
    for (; (t = t.host) && p.docFrag(t); )
      ;
    return t;
  }
  return t;
}
function Tt(e, t) {
  return pt !== bn && (t = t.replace(/\/deep\//g, " ")), e[G.prefixedMatchesSelector](t);
}
function be(e, t, n) {
  for (; p.element(e); ) {
    if (Tt(e, t))
      return true;
    if (e = gt(e), e === n)
      return Tt(e, t);
  }
  return false;
}
function je(e) {
  return e.correspondingUseElement || e;
}
function Ci(e) {
  return e = e || pt, {
    x: e.scrollX || e.document.documentElement.scrollLeft,
    y: e.scrollY || e.document.documentElement.scrollTop
  };
}
function Ie(e) {
  const t = e instanceof q.SVGElement ? e.getBoundingClientRect() : e.getClientRects()[0];
  return t && {
    left: t.left,
    right: t.right,
    top: t.top,
    bottom: t.bottom,
    width: t.width || t.right - t.left,
    height: t.height || t.bottom - t.top
  };
}
function Te(e) {
  const t = Ie(e);
  if (!G.isIOS7 && t) {
    const n = Ci(It(e));
    t.left += n.x, t.right += n.x, t.top += n.y, t.bottom += n.y;
  }
  return t;
}
function Xe(e) {
  return p.string(e) ? (q.document.querySelector(e), true) : false;
}
var _i = ["webkit", "moz"];
function Tn(e, t) {
  e.__set || (e.__set = {});
  for (const n in t)
    _i.some((i) => n.indexOf(i) === 0) || typeof e[n] != "function" && n !== "__set" && Object.defineProperty(e, n, {
      get() {
        return n in e.__set ? e.__set[n] : e.__set[n] = t[n];
      },
      set(i) {
        e.__set[n] = i;
      },
      configurable: true
    });
  return e;
}
var oe = (e, t) => Math.sqrt(e * e + t * t);
function fe(e, t) {
  e.page = e.page || {}, e.page.x = t.page.x, e.page.y = t.page.y, e.client = e.client || {}, e.client.x = t.client.x, e.client.y = t.client.y, e.timeStamp = t.timeStamp;
}
function Pi(e, t, n) {
  e.page.x = n.page.x - t.page.x, e.page.y = n.page.y - t.page.y, e.client.x = n.client.x - t.client.x, e.client.y = n.client.y - t.client.y, e.timeStamp = n.timeStamp - t.timeStamp;
}
function Oi(e, t) {
  const n = Math.max(t.timeStamp / 1e3, 1e-3);
  e.page.x = t.page.x / n, e.page.y = t.page.y / n, e.client.x = t.client.x / n, e.client.y = t.client.y / n, e.timeStamp = n;
}
function Ri(e) {
  e.page.x = 0, e.page.y = 0, e.client.x = 0, e.client.y = 0;
}
function Dn(e) {
  return e instanceof q.Event || e instanceof q.Touch;
}
function Qt(e, t, n) {
  return n = n || {}, e = e || "page", n.x = t[e + "X"], n.y = t[e + "Y"], n;
}
function ki(e, t) {
  return t = t || {
    x: 0,
    y: 0
  }, G.isOperaMobile && Dn(e) ? (Qt("screen", e, t), t.x += window.scrollX, t.y += window.scrollY) : Qt("page", e, t), t;
}
function Ai(e, t) {
  return t = t || {}, G.isOperaMobile && Dn(e) ? Qt("screen", e, t) : Qt("client", e, t), t;
}
function te(e) {
  return p.number(e.pointerId) ? e.pointerId : e.identifier;
}
function $i(e, t, n) {
  const i = t.length > 1 ? Mn(t) : t[0];
  ki(i, e.page), Ai(i, e.client), e.timeStamp = n;
}
function De(e) {
  const t = [];
  return p.array(e) ? (t[0] = e[0], t[1] = e[1]) : e.type === "touchend" ? e.touches.length === 1 ? (t[0] = e.touches[0], t[1] = e.changedTouches[0]) : e.touches.length === 0 && (t[0] = e.changedTouches[0], t[1] = e.changedTouches[1]) : (t[0] = e.touches[0], t[1] = e.touches[1]), t;
}
function Mn(e) {
  const t = {
    pageX: 0,
    pageY: 0,
    clientX: 0,
    clientY: 0,
    screenX: 0,
    screenY: 0
  };
  for (const n of e)
    for (const i in t)
      t[i] += n[i];
  for (const n in t)
    t[n] /= e.length;
  return t;
}
function Hi(e) {
  if (!e.length)
    return null;
  const t = De(e), n = Math.min(t[0].pageX, t[1].pageX), i = Math.min(t[0].pageY, t[1].pageY), o = Math.max(t[0].pageX, t[1].pageX), s = Math.max(t[0].pageY, t[1].pageY);
  return {
    x: n,
    y: i,
    left: n,
    top: i,
    right: o,
    bottom: s,
    width: o - n,
    height: s - i
  };
}
function Li(e, t) {
  const n = t + "X", i = t + "Y", o = De(e), s = o[0][n] - o[1][n], a = o[0][i] - o[1][i];
  return oe(s, a);
}
function Wi(e, t) {
  const n = t + "X", i = t + "Y", o = De(e), s = o[1][n] - o[0][n], a = o[1][i] - o[0][i];
  return 180 * Math.atan2(a, s) / Math.PI;
}
function Bi(e) {
  return p.string(e.pointerType) ? e.pointerType : p.number(e.pointerType) ? [void 0, void 0, "touch", "pen", "mouse"][e.pointerType] : (
    // if the PointerEvent API isn't available, then the "pointer" must
    // be either a MouseEvent, TouchEvent, or Touch object
    /touch/.test(e.type || "") || e instanceof q.Touch ? "touch" : "mouse"
  );
}
function Cn(e) {
  const t = p.func(e.composedPath) ? e.composedPath() : e.path;
  return [je(t ? t[0] : e.target), je(e.currentTarget)];
}
function At() {
  return {
    page: {
      x: 0,
      y: 0
    },
    client: {
      x: 0,
      y: 0
    },
    timeStamp: 0
  };
}
function Ni(e) {
  var t;
  const n = [], i = {}, o = [], s = {
    add: a,
    remove: l,
    addDelegate: c,
    removeDelegate: r,
    delegateListener: f,
    delegateUseCapture: d,
    delegatedEvents: i,
    documents: o,
    targets: n,
    supportsOptions: false,
    supportsPassive: false
  };
  (t = e.document) == null || t.createElement("div").addEventListener("test", null, {
    get capture() {
      return s.supportsOptions = true;
    },
    get passive() {
      return s.supportsPassive = true;
    }
  }), e.events = s;
  function a(m, g, b, C) {
    if (!m.addEventListener)
      return;
    const k = $t(C);
    let A = Jt(n, (S) => S.eventTarget === m);
    A || (A = {
      eventTarget: m,
      events: {}
    }, n.push(A)), A.events[g] || (A.events[g] = []), Jt(A.events[g], (S) => S.func === b && Vt(S.options, k)) || (m.addEventListener(g, b, s.supportsOptions ? k : k.capture), A.events[g].push({
      func: b,
      options: k
    }));
  }
  function l(m, g, b, C) {
    if (!m.addEventListener || !m.removeEventListener)
      return;
    const k = re(n, (v) => v.eventTarget === m), A = n[k];
    if (!A || !A.events)
      return;
    if (g === "all") {
      for (g in A.events)
        A.events.hasOwnProperty(g) && l(m, g, "all");
      return;
    }
    let S = false;
    const _ = A.events[g];
    if (_)
      if (b === "all") {
        for (let v = _.length - 1; v >= 0; v--) {
          const u = _[v];
          l(m, g, u.func, u.options);
        }
        return;
      } else {
        const v = $t(C);
        for (let u = 0; u < _.length; u++) {
          const w = _[u];
          if (w.func === b && Vt(w.options, v)) {
            m.removeEventListener(g, b, s.supportsOptions ? v : v.capture), _.splice(u, 1), _.length === 0 && (delete A.events[g], S = true);
            break;
          }
        }
      }
    S && !Object.keys(A.events).length && n.splice(k, 1);
  }
  function c(m, g, b, C, k) {
    const A = $t(k);
    if (!i[b]) {
      i[b] = [];
      for (const v of o)
        a(v, b, f), a(v, b, d, true);
    }
    const S = i[b];
    let _ = Jt(S, (v) => v.selector === m && v.context === g);
    _ || (_ = {
      selector: m,
      context: g,
      listeners: []
    }, S.push(_)), _.listeners.push({
      func: C,
      options: A
    });
  }
  function r(m, g, b, C, k) {
    const A = $t(k), S = i[b];
    let _ = false, v;
    if (S)
      for (v = S.length - 1; v >= 0; v--) {
        const u = S[v];
        if (u.selector === m && u.context === g) {
          const {
            listeners: w
          } = u;
          for (let y = w.length - 1; y >= 0; y--) {
            const T = w[y];
            if (T.func === C && Vt(T.options, A)) {
              w.splice(y, 1), w.length || (S.splice(v, 1), l(g, b, f), l(g, b, d, true)), _ = true;
              break;
            }
          }
          if (_)
            break;
        }
      }
  }
  function f(m, g) {
    const b = $t(g), C = new Fi(m), k = i[m.type], [A] = Cn(m);
    let S = A;
    for (; p.element(S); ) {
      for (let _ = 0; _ < k.length; _++) {
        const v = k[_], {
          selector: u,
          context: w
        } = v;
        if (Tt(S, u) && zt(w, A) && zt(w, S)) {
          const {
            listeners: y
          } = v;
          C.currentTarget = S;
          for (const T of y)
            Vt(T.options, b) && T.func(C);
        }
      }
      S = gt(S);
    }
  }
  function d(m) {
    return f.call(this, m, true);
  }
  return s;
}
var Fi = class {
  constructor(t) {
    this.currentTarget = void 0, this.originalEvent = void 0, this.type = void 0, this.originalEvent = t, Tn(this, t);
  }
  preventOriginalDefault() {
    this.originalEvent.preventDefault();
  }
  stopPropagation() {
    this.originalEvent.stopPropagation();
  }
  stopImmediatePropagation() {
    this.originalEvent.stopImmediatePropagation();
  }
};
function $t(e) {
  return p.object(e) ? {
    capture: !!e.capture,
    passive: !!e.passive
  } : {
    capture: !!e,
    passive: false
  };
}
function Vt(e, t) {
  return e === t ? true : typeof e == "boolean" ? !!t.capture === e && !t.passive : !!e.capture == !!t.capture && !!e.passive == !!t.passive;
}
var ji = {
  id: "events",
  install: Ni
};
var Xi = function(t) {
  return /^(always|never|auto)$/.test(t) ? (this.options.preventDefault = t, this) : p.bool(t) ? (this.options.preventDefault = t ? "always" : "never", this) : this.options.preventDefault;
};
function Yi(e, t, n) {
  const i = e.options.preventDefault;
  if (i !== "never") {
    if (i === "always") {
      n.preventDefault();
      return;
    }
    if (t.events.supportsPassive && /^touch(start|move)$/.test(n.type)) {
      const o = It(n.target).document, s = t.getDocOptions(o);
      if (!(s && s.events) || s.events.passive !== false)
        return;
    }
    /^(mouse|pointer|touch)*(down|start)/i.test(n.type) || p.element(n.target) && Tt(n.target, "input,select,textarea,[contenteditable=true],[contenteditable=true] *") || n.preventDefault();
  }
}
function qi(e) {
  let {
    interaction: t,
    event: n
  } = e;
  t.interactable && t.interactable.checkAndPreventDefault(n);
}
function Gi(e) {
  const {
    Interactable: t
  } = e;
  t.prototype.preventDefault = Xi, t.prototype.checkAndPreventDefault = function(n) {
    return Yi(this, e, n);
  }, e.interactions.docEvents.push({
    type: "dragstart",
    listener(n) {
      for (const i of e.interactions.list)
        if (i.element && (i.element === n.target || zt(i.element, n.target))) {
          i.interactable.checkAndPreventDefault(n);
          return;
        }
    }
  });
}
var Ui = {
  id: "core/interactablePreventDefault",
  install: Gi,
  listeners: ["down", "move", "up", "cancel"].reduce((e, t) => (e[`interactions:${t}`] = qi, e), {})
};
function Xt(e, t) {
  let n = false;
  return function() {
    return n || (pt.console.warn(t), n = true), e.apply(this, arguments);
  };
}
function _n(e, t) {
  return e.name = t.name, e.axis = t.axis, e.edges = t.edges, e;
}
function Pn(e, t, n) {
  return e === "parent" ? gt(n) : e === "self" ? t.getRect(n) : In(n, e);
}
function Yt(e, t, n, i) {
  let o = e;
  return p.string(o) ? o = Pn(o, t, n) : p.func(o) && (o = o(...i)), p.element(o) && (o = Te(o)), o;
}
function se(e) {
  return e && {
    x: "x" in e ? e.x : e.left,
    y: "y" in e ? e.y : e.top
  };
}
function Vi(e) {
  return e && !("left" in e && "top" in e) && (e = I({}, e), e.left = e.x || 0, e.top = e.y || 0, e.right = e.right || e.left + e.width, e.bottom = e.bottom || e.top + e.height), e;
}
function Ye(e) {
  return e && !("x" in e && "y" in e) && (e = I({}, e), e.x = e.left || 0, e.y = e.top || 0, e.width = e.width || (e.right || 0) - e.x, e.height = e.height || (e.bottom || 0) - e.y), e;
}
function Me(e, t, n) {
  e.left && (t.left += n.x), e.right && (t.right += n.x), e.top && (t.top += n.y), e.bottom && (t.bottom += n.y), t.width = t.right - t.left, t.height = t.bottom - t.top;
}
function Ce(e, t, n) {
  const i = n && e.options[n], s = i && i.origin || e.options.origin, a = Yt(s, e, t, [e && t]);
  return se(a) || {
    x: 0,
    y: 0
  };
}
var On = class {
  constructor(t) {
    this.immediatePropagationStopped = false, this.propagationStopped = false, this._interaction = t;
  }
  preventDefault() {
  }
  /**
   * Don't call any other listeners (even on the current target)
   */
  stopPropagation() {
    this.propagationStopped = true;
  }
  /**
   * Don't call listeners on the remaining targets
   */
  stopImmediatePropagation() {
    this.immediatePropagationStopped = this.propagationStopped = true;
  }
};
Object.defineProperty(On.prototype, "interaction", {
  get() {
    return this._interaction._proxy;
  },
  set() {
  }
});
var Rn = {
  base: {
    preventDefault: "auto",
    deltaSource: "page"
  },
  perAction: {
    enabled: false,
    origin: {
      x: 0,
      y: 0
    }
  },
  actions: {}
};
var _e = class extends On {
  constructor(t, n, i, o, s, a, l) {
    super(t), this.relatedTarget = null, this.screenX = void 0, this.screenY = void 0, this.button = void 0, this.buttons = void 0, this.ctrlKey = void 0, this.shiftKey = void 0, this.altKey = void 0, this.metaKey = void 0, this.page = void 0, this.client = void 0, this.delta = void 0, this.rect = void 0, this.x0 = void 0, this.y0 = void 0, this.t0 = void 0, this.dt = void 0, this.duration = void 0, this.clientX0 = void 0, this.clientY0 = void 0, this.velocity = void 0, this.speed = void 0, this.swipe = void 0, this.axes = void 0, this.preEnd = void 0, s = s || t.element;
    const c = t.interactable, r = (c && c.options || Rn).deltaSource, f = Ce(c, s, i), d = o === "start", m = o === "end", g = d ? this : t.prevEvent, b = d ? t.coords.start : m ? {
      page: g.page,
      client: g.client,
      timeStamp: t.coords.cur.timeStamp
    } : t.coords.cur;
    this.page = I({}, b.page), this.client = I({}, b.client), this.rect = I({}, t.rect), this.timeStamp = b.timeStamp, m || (this.page.x -= f.x, this.page.y -= f.y, this.client.x -= f.x, this.client.y -= f.y), this.ctrlKey = n.ctrlKey, this.altKey = n.altKey, this.shiftKey = n.shiftKey, this.metaKey = n.metaKey, this.button = n.button, this.buttons = n.buttons, this.target = s, this.currentTarget = s, this.preEnd = a, this.type = l || i + (o || ""), this.interactable = c, this.t0 = d ? t.pointers[t.pointers.length - 1].downTime : g.t0, this.x0 = t.coords.start.page.x - f.x, this.y0 = t.coords.start.page.y - f.y, this.clientX0 = t.coords.start.client.x - f.x, this.clientY0 = t.coords.start.client.y - f.y, d || m ? this.delta = {
      x: 0,
      y: 0
    } : this.delta = {
      x: this[r].x - g[r].x,
      y: this[r].y - g[r].y
    }, this.dt = t.coords.delta.timeStamp, this.duration = this.timeStamp - this.t0, this.velocity = I({}, t.coords.velocity[r]), this.speed = oe(this.velocity.x, this.velocity.y), this.swipe = m || o === "inertiastart" ? this.getSwipe() : null;
  }
  getSwipe() {
    const t = this._interaction;
    if (t.prevEvent.speed < 600 || this.timeStamp - t.prevEvent.timeStamp > 150)
      return null;
    let n = 180 * Math.atan2(t.prevEvent.velocityY, t.prevEvent.velocityX) / Math.PI;
    const i = 22.5;
    n < 0 && (n += 360);
    const o = 135 - i <= n && n < 225 + i, s = 225 - i <= n && n < 315 + i, a = !o && (315 - i <= n || n < 45 + i), l = !s && 45 - i <= n && n < 135 + i;
    return {
      up: s,
      down: l,
      left: o,
      right: a,
      angle: n,
      speed: t.prevEvent.speed,
      velocity: {
        x: t.prevEvent.velocityX,
        y: t.prevEvent.velocityY
      }
    };
  }
  preventDefault() {
  }
  /**
   * Don't call listeners on the remaining targets
   */
  stopImmediatePropagation() {
    this.immediatePropagationStopped = this.propagationStopped = true;
  }
  /**
   * Don't call any other listeners (even on the current target)
   */
  stopPropagation() {
    this.propagationStopped = true;
  }
};
Object.defineProperties(_e.prototype, {
  pageX: {
    get() {
      return this.page.x;
    },
    set(e) {
      this.page.x = e;
    }
  },
  pageY: {
    get() {
      return this.page.y;
    },
    set(e) {
      this.page.y = e;
    }
  },
  clientX: {
    get() {
      return this.client.x;
    },
    set(e) {
      this.client.x = e;
    }
  },
  clientY: {
    get() {
      return this.client.y;
    },
    set(e) {
      this.client.y = e;
    }
  },
  dx: {
    get() {
      return this.delta.x;
    },
    set(e) {
      this.delta.x = e;
    }
  },
  dy: {
    get() {
      return this.delta.y;
    },
    set(e) {
      this.delta.y = e;
    }
  },
  velocityX: {
    get() {
      return this.velocity.x;
    },
    set(e) {
      this.velocity.x = e;
    }
  },
  velocityY: {
    get() {
      return this.velocity.y;
    },
    set(e) {
      this.velocity.y = e;
    }
  }
});
var Ki = class {
  constructor(t, n, i, o, s) {
    this.id = void 0, this.pointer = void 0, this.event = void 0, this.downTime = void 0, this.downTarget = void 0, this.id = t, this.pointer = n, this.event = i, this.downTime = o, this.downTarget = s;
  }
};
var Ji = function(e) {
  return e.interactable = "", e.element = "", e.prepared = "", e.pointerIsDown = "", e.pointerWasMoved = "", e._proxy = "", e;
}({});
var Zi = function(e) {
  return e.start = "", e.move = "", e.end = "", e.stop = "", e.interacting = "", e;
}({});
var Qi = 0;
var tr = class {
  /** @internal */
  get pointerMoveTolerance() {
    return 1;
  }
  constructor(t) {
    this.interactable = null, this.element = null, this.rect = null, this._rects = void 0, this.edges = null, this._scopeFire = void 0, this.prepared = {
      name: null,
      axis: null,
      edges: null
    }, this.pointerType = void 0, this.pointers = [], this.downEvent = null, this.downPointer = {}, this._latestPointer = {
      pointer: null,
      event: null,
      eventTarget: null
    }, this.prevEvent = null, this.pointerIsDown = false, this.pointerWasMoved = false, this._interacting = false, this._ending = false, this._stopped = true, this._proxy = void 0, this.simulation = null, this.doMove = Xt(function(s) {
      this.move(s);
    }, "The interaction.doMove() method has been renamed to interaction.move()"), this.coords = {
      // Starting InteractEvent pointer coordinates
      start: At(),
      // Previous native pointer move event coordinates
      prev: At(),
      // current native pointer move event coordinates
      cur: At(),
      // Change in coordinates and time of the pointer
      delta: At(),
      // pointer velocity
      velocity: At()
    }, this._id = Qi++;
    let {
      pointerType: n,
      scopeFire: i
    } = t;
    this._scopeFire = i, this.pointerType = n;
    const o = this;
    this._proxy = {};
    for (const s in Ji)
      Object.defineProperty(this._proxy, s, {
        get() {
          return o[s];
        }
      });
    for (const s in Zi)
      Object.defineProperty(this._proxy, s, {
        value: function() {
          return o[s](...arguments);
        }
      });
    this._scopeFire("interactions:new", {
      interaction: this
    });
  }
  pointerDown(t, n, i) {
    const o = this.updatePointer(t, n, i, true), s = this.pointers[o];
    this._scopeFire("interactions:down", {
      pointer: t,
      event: n,
      eventTarget: i,
      pointerIndex: o,
      pointerInfo: s,
      type: "down",
      interaction: this
    });
  }
  /**
   * ```js
   * interact(target)
   *   .draggable({
   *     // disable the default drag start by down->move
   *     manualStart: true
   *   })
   *   // start dragging after the user holds the pointer down
   *   .on('hold', function (event) {
   *     var interaction = event.interaction
   *
   *     if (!interaction.interacting()) {
   *       interaction.start({ name: 'drag' },
   *                         event.interactable,
   *                         event.currentTarget)
   *     }
   * })
   * ```
   *
   * Start an action with the given Interactable and Element as tartgets. The
   * action must be enabled for the target Interactable and an appropriate
   * number of pointers must be held down - 1 for drag/resize, 2 for gesture.
   *
   * Use it with `interactable.<action>able({ manualStart: false })` to always
   * [start actions manually](https://github.com/taye/interact.js/issues/114)
   *
   * @param action - The action to be performed - drag, resize, etc.
   * @param target - The Interactable to target
   * @param element - The DOM Element to target
   * @returns Whether the interaction was successfully started
   */
  start(t, n, i) {
    return this.interacting() || !this.pointerIsDown || this.pointers.length < (t.name === "gesture" ? 2 : 1) || !n.options[t.name].enabled ? false : (_n(this.prepared, t), this.interactable = n, this.element = i, this.rect = n.getRect(i), this.edges = this.prepared.edges ? I({}, this.prepared.edges) : {
      left: true,
      right: true,
      top: true,
      bottom: true
    }, this._stopped = false, this._interacting = this._doPhase({
      interaction: this,
      event: this.downEvent,
      phase: "start"
    }) && !this._stopped, this._interacting);
  }
  pointerMove(t, n, i) {
    !this.simulation && !(this.modification && this.modification.endResult) && this.updatePointer(t, n, i, false);
    const o = this.coords.cur.page.x === this.coords.prev.page.x && this.coords.cur.page.y === this.coords.prev.page.y && this.coords.cur.client.x === this.coords.prev.client.x && this.coords.cur.client.y === this.coords.prev.client.y;
    let s, a;
    this.pointerIsDown && !this.pointerWasMoved && (s = this.coords.cur.client.x - this.coords.start.client.x, a = this.coords.cur.client.y - this.coords.start.client.y, this.pointerWasMoved = oe(s, a) > this.pointerMoveTolerance);
    const l = this.getPointerIndex(t), c = {
      pointer: t,
      pointerIndex: l,
      pointerInfo: this.pointers[l],
      event: n,
      type: "move",
      eventTarget: i,
      dx: s,
      dy: a,
      duplicate: o,
      interaction: this
    };
    o || Oi(this.coords.velocity, this.coords.delta), this._scopeFire("interactions:move", c), !o && !this.simulation && (this.interacting() && (c.type = null, this.move(c)), this.pointerWasMoved && fe(this.coords.prev, this.coords.cur));
  }
  /**
   * ```js
   * interact(target)
   *   .draggable(true)
   *   .on('dragmove', function (event) {
   *     if (someCondition) {
   *       // change the snap settings
   *       event.interactable.draggable({ snap: { targets: [] }})
   *       // fire another move event with re-calculated snap
   *       event.interaction.move()
   *     }
   *   })
   * ```
   *
   * Force a move of the current action at the same coordinates. Useful if
   * snap/restrict has been changed and you want a movement with the new
   * settings.
   */
  move(t) {
    (!t || !t.event) && Ri(this.coords.delta), t = I({
      pointer: this._latestPointer.pointer,
      event: this._latestPointer.event,
      eventTarget: this._latestPointer.eventTarget,
      interaction: this
    }, t || {}), t.phase = "move", this._doPhase(t);
  }
  /**
   * @internal
   * End interact move events and stop auto-scroll unless simulation is running
   */
  pointerUp(t, n, i, o) {
    let s = this.getPointerIndex(t);
    s === -1 && (s = this.updatePointer(t, n, i, false));
    const a = /cancel$/i.test(n.type) ? "cancel" : "up";
    this._scopeFire(`interactions:${a}`, {
      pointer: t,
      pointerIndex: s,
      pointerInfo: this.pointers[s],
      event: n,
      eventTarget: i,
      type: a,
      curEventTarget: o,
      interaction: this
    }), this.simulation || this.end(n), this.removePointer(t, n);
  }
  /** @internal */
  documentBlur(t) {
    this.end(t), this._scopeFire("interactions:blur", {
      event: t,
      type: "blur",
      interaction: this
    });
  }
  /**
   * ```js
   * interact(target)
   *   .draggable(true)
   *   .on('move', function (event) {
   *     if (event.pageX > 1000) {
   *       // end the current action
   *       event.interaction.end()
   *       // stop all further listeners from being called
   *       event.stopImmediatePropagation()
   *     }
   *   })
   * ```
   */
  end(t) {
    this._ending = true, t = t || this._latestPointer.event;
    let n;
    this.interacting() && (n = this._doPhase({
      event: t,
      interaction: this,
      phase: "end"
    })), this._ending = false, n === true && this.stop();
  }
  currentAction() {
    return this._interacting ? this.prepared.name : null;
  }
  interacting() {
    return this._interacting;
  }
  stop() {
    this._scopeFire("interactions:stop", {
      interaction: this
    }), this.interactable = this.element = null, this._interacting = false, this._stopped = true, this.prepared.name = this.prevEvent = null;
  }
  /** @internal */
  getPointerIndex(t) {
    const n = te(t);
    return this.pointerType === "mouse" || this.pointerType === "pen" ? this.pointers.length - 1 : re(this.pointers, (i) => i.id === n);
  }
  /** @internal */
  getPointerInfo(t) {
    return this.pointers[this.getPointerIndex(t)];
  }
  /** @internal */
  updatePointer(t, n, i, o) {
    const s = te(t);
    let a = this.getPointerIndex(t), l = this.pointers[a];
    return o = o === false ? false : o || /(down|start)$/i.test(n.type), l ? l.pointer = t : (l = new Ki(s, t, n, null, null), a = this.pointers.length, this.pointers.push(l)), $i(this.coords.cur, this.pointers.map((c) => c.pointer), this._now()), Pi(this.coords.delta, this.coords.prev, this.coords.cur), o && (this.pointerIsDown = true, l.downTime = this.coords.cur.timeStamp, l.downTarget = i, Tn(this.downPointer, t), this.interacting() || (fe(this.coords.start, this.coords.cur), fe(this.coords.prev, this.coords.cur), this.downEvent = n, this.pointerWasMoved = false)), this._updateLatestPointer(t, n, i), this._scopeFire("interactions:update-pointer", {
      pointer: t,
      event: n,
      eventTarget: i,
      down: o,
      pointerInfo: l,
      pointerIndex: a,
      interaction: this
    }), a;
  }
  /** @internal */
  removePointer(t, n) {
    const i = this.getPointerIndex(t);
    if (i === -1)
      return;
    const o = this.pointers[i];
    this._scopeFire("interactions:remove-pointer", {
      pointer: t,
      event: n,
      eventTarget: null,
      pointerIndex: i,
      pointerInfo: o,
      interaction: this
    }), this.pointers.splice(i, 1), this.pointerIsDown = false;
  }
  /** @internal */
  _updateLatestPointer(t, n, i) {
    this._latestPointer.pointer = t, this._latestPointer.event = n, this._latestPointer.eventTarget = i;
  }
  destroy() {
    this._latestPointer.pointer = null, this._latestPointer.event = null, this._latestPointer.eventTarget = null;
  }
  /** @internal */
  _createPreparedEvent(t, n, i, o) {
    return new _e(this, t, this.prepared.name, n, this.element, i, o);
  }
  /** @internal */
  _fireEvent(t) {
    var n;
    (n = this.interactable) == null || n.fire(t), (!this.prevEvent || t.timeStamp >= this.prevEvent.timeStamp) && (this.prevEvent = t);
  }
  /** @internal */
  _doPhase(t) {
    const {
      event: n,
      phase: i,
      preEnd: o,
      type: s
    } = t, {
      rect: a
    } = this;
    if (a && i === "move" && (Me(this.edges, a, this.coords.delta[this.interactable.options.deltaSource]), a.width = a.right - a.left, a.height = a.bottom - a.top), this._scopeFire(`interactions:before-action-${i}`, t) === false)
      return false;
    const c = t.iEvent = this._createPreparedEvent(n, i, o, s);
    return this._scopeFire(`interactions:action-${i}`, t), i === "start" && (this.prevEvent = c), this._fireEvent(c), this._scopeFire(`interactions:after-action-${i}`, t), true;
  }
  /** @internal */
  _now() {
    return Date.now();
  }
};
var xe = {
  methodOrder: ["simulationResume", "mouseOrPen", "hasPointer", "idle"],
  search(e) {
    for (const t of xe.methodOrder) {
      const n = xe[t](e);
      if (n)
        return n;
    }
    return null;
  },
  // try to resume simulation with a new pointer
  simulationResume(e) {
    let {
      pointerType: t,
      eventType: n,
      eventTarget: i,
      scope: o
    } = e;
    if (!/down|start/i.test(n))
      return null;
    for (const s of o.interactions.list) {
      let a = i;
      if (s.simulation && s.simulation.allowResume && s.pointerType === t)
        for (; a; ) {
          if (a === s.element)
            return s;
          a = gt(a);
        }
    }
    return null;
  },
  // if it's a mouse or pen interaction
  mouseOrPen(e) {
    let {
      pointerId: t,
      pointerType: n,
      eventType: i,
      scope: o
    } = e;
    if (n !== "mouse" && n !== "pen")
      return null;
    let s;
    for (const a of o.interactions.list)
      if (a.pointerType === n) {
        if (a.simulation && !qe(a, t))
          continue;
        if (a.interacting())
          return a;
        s || (s = a);
      }
    if (s)
      return s;
    for (const a of o.interactions.list)
      if (a.pointerType === n && !(/down/i.test(i) && a.simulation))
        return a;
    return null;
  },
  // get interaction that has this pointer
  hasPointer(e) {
    let {
      pointerId: t,
      scope: n
    } = e;
    for (const i of n.interactions.list)
      if (qe(i, t))
        return i;
    return null;
  },
  // get first idle interaction with a matching pointerType
  idle(e) {
    let {
      pointerType: t,
      scope: n
    } = e;
    for (const i of n.interactions.list) {
      if (i.pointers.length === 1) {
        const o = i.interactable;
        if (o && !(o.options.gesture && o.options.gesture.enabled))
          continue;
      } else if (i.pointers.length >= 2)
        continue;
      if (!i.interacting() && t === i.pointerType)
        return i;
    }
    return null;
  }
};
function qe(e, t) {
  return e.pointers.some((n) => {
    let {
      id: i
    } = n;
    return i === t;
  });
}
var kn = ["pointerDown", "pointerMove", "pointerUp", "updatePointer", "removePointer", "windowBlur"];
function er(e) {
  const t = {};
  for (const s of kn)
    t[s] = An(s, e);
  const n = G.pEventTypes;
  let i;
  q.PointerEvent ? i = [{
    type: n.down,
    listener: o
  }, {
    type: n.down,
    listener: t.pointerDown
  }, {
    type: n.move,
    listener: t.pointerMove
  }, {
    type: n.up,
    listener: t.pointerUp
  }, {
    type: n.cancel,
    listener: t.pointerUp
  }] : i = [{
    type: "mousedown",
    listener: t.pointerDown
  }, {
    type: "mousemove",
    listener: t.pointerMove
  }, {
    type: "mouseup",
    listener: t.pointerUp
  }, {
    type: "touchstart",
    listener: o
  }, {
    type: "touchstart",
    listener: t.pointerDown
  }, {
    type: "touchmove",
    listener: t.pointerMove
  }, {
    type: "touchend",
    listener: t.pointerUp
  }, {
    type: "touchcancel",
    listener: t.pointerUp
  }], i.push({
    type: "blur",
    listener(s) {
      for (const a of e.interactions.list)
        a.documentBlur(s);
    }
  }), e.prevTouchTime = 0, e.Interaction = class extends tr {
    get pointerMoveTolerance() {
      return e.interactions.pointerMoveTolerance;
    }
    set pointerMoveTolerance(s) {
      e.interactions.pointerMoveTolerance = s;
    }
    _now() {
      return e.now();
    }
  }, e.interactions = {
    // all active and idle interactions
    list: [],
    new(s) {
      s.scopeFire = (l, c) => e.fire(l, c);
      const a = new e.Interaction(s);
      return e.interactions.list.push(a), a;
    },
    listeners: t,
    docEvents: i,
    pointerMoveTolerance: 1
  };
  function o() {
    for (const s of e.interactions.list)
      if (!(!s.pointerIsDown || s.pointerType !== "touch" || s._interacting))
        for (const a of s.pointers)
          e.documents.some((l) => {
            let {
              doc: c
            } = l;
            return zt(c, a.downTarget);
          }) || s.removePointer(a.pointer, a.event);
  }
  e.usePlugin(Ui);
}
function An(e, t) {
  return function(n) {
    const i = t.interactions.list, o = Bi(n), [s, a] = Cn(n), l = [];
    if (/^touch/.test(n.type)) {
      t.prevTouchTime = t.now();
      for (const c of n.changedTouches) {
        const r = c, f = te(r), d = {
          pointer: r,
          pointerId: f,
          pointerType: o,
          eventType: n.type,
          eventTarget: s,
          curEventTarget: a,
          scope: t
        }, m = Ge(d);
        l.push([d.pointer, d.eventTarget, d.curEventTarget, m]);
      }
    } else {
      let c = false;
      if (!G.supportsPointerEvent && /mouse/.test(n.type)) {
        for (let r = 0; r < i.length && !c; r++)
          c = i[r].pointerType !== "mouse" && i[r].pointerIsDown;
        c = c || t.now() - t.prevTouchTime < 500 || // on iOS and Firefox Mobile, MouseEvent.timeStamp is zero if simulated
        n.timeStamp === 0;
      }
      if (!c) {
        const r = {
          pointer: n,
          pointerId: te(n),
          pointerType: o,
          eventType: n.type,
          curEventTarget: a,
          eventTarget: s,
          scope: t
        }, f = Ge(r);
        l.push([r.pointer, r.eventTarget, r.curEventTarget, f]);
      }
    }
    for (const [c, r, f, d] of l)
      d[e](c, n, r, f);
  };
}
function Ge(e) {
  const {
    pointerType: t,
    scope: n
  } = e, o = {
    interaction: xe.search(e),
    searchDetails: e
  };
  return n.fire("interactions:find", o), o.interaction || n.interactions.new({
    pointerType: t
  });
}
function de(e, t) {
  let {
    doc: n,
    scope: i,
    options: o
  } = e;
  const {
    interactions: {
      docEvents: s
    },
    events: a
  } = i, l = a[t];
  i.browser.isIOS && !o.events && (o.events = {
    passive: false
  });
  for (const r in a.delegatedEvents)
    l(n, r, a.delegateListener), l(n, r, a.delegateUseCapture, true);
  const c = o && o.events;
  for (const {
    type: r,
    listener: f
  } of s)
    l(n, r, f, c);
}
var nr = {
  id: "core/interactions",
  install: er,
  listeners: {
    "scope:add-document": (e) => de(e, "add"),
    "scope:remove-document": (e) => de(e, "remove"),
    "interactable:unset": (e, t) => {
      let {
        interactable: n
      } = e;
      for (let i = t.interactions.list.length - 1; i >= 0; i--) {
        const o = t.interactions.list[i];
        o.interactable === n && (o.stop(), t.fire("interactions:destroy", {
          interaction: o
        }), o.destroy(), t.interactions.list.length > 2 && t.interactions.list.splice(i, 1));
      }
    }
  },
  onDocSignal: de,
  doOnInteractions: An,
  methodNames: kn
};
function qt(e, t) {
  if (t.phaselessTypes[e])
    return true;
  for (const n in t.map)
    if (e.indexOf(n) === 0 && e.substr(n.length) in t.phases)
      return true;
  return false;
}
var ht = function(e) {
  return e[e.On = 0] = "On", e[e.Off = 1] = "Off", e;
}(ht || {});
var ir = class {
  /** @internal */
  get _defaults() {
    return {
      base: {},
      perAction: {},
      actions: {}
    };
  }
  constructor(t, n, i, o) {
    this.target = void 0, this.options = void 0, this._actions = void 0, this.events = new zn(), this._context = void 0, this._win = void 0, this._doc = void 0, this._scopeEvents = void 0, this._actions = n.actions, this.target = t, this._context = n.context || i, this._win = It(Xe(t) ? this._context : t), this._doc = this._win.document, this._scopeEvents = o, this.set(n);
  }
  setOnEvents(t, n) {
    return p.func(n.onstart) && this.on(`${t}start`, n.onstart), p.func(n.onmove) && this.on(`${t}move`, n.onmove), p.func(n.onend) && this.on(`${t}end`, n.onend), p.func(n.oninertiastart) && this.on(`${t}inertiastart`, n.oninertiastart), this;
  }
  updatePerActionListeners(t, n, i) {
    var o;
    const s = (o = this._actions.map[t]) == null ? void 0 : o.filterEventType, a = (l) => (s == null || s(l)) && qt(l, this._actions);
    (p.array(n) || p.object(n)) && this._onOff(ht.Off, t, n, void 0, a), (p.array(i) || p.object(i)) && this._onOff(ht.On, t, i, void 0, a);
  }
  setPerAction(t, n) {
    const i = this._defaults;
    for (const o in n) {
      const s = o, a = this.options[t], l = n[s];
      s === "listeners" && this.updatePerActionListeners(t, a.listeners, l), p.array(l) ? a[s] = En(l) : p.plainObject(l) ? (a[s] = I(a[s] || {}, Rt(l)), p.object(i.perAction[s]) && "enabled" in i.perAction[s] && (a[s].enabled = l.enabled !== false)) : p.bool(l) && p.object(i.perAction[s]) ? a[s].enabled = l : a[s] = l;
    }
  }
  /**
   * The default function to get an Interactables bounding rect. Can be
   * overridden using {@link Interactable.rectChecker}.
   *
   * @param {Element} [element] The element to measure.
   * @return {Rect} The object's bounding rectangle.
   */
  getRect(t) {
    return t = t || (p.element(this.target) ? this.target : null), p.string(this.target) && (t = t || this._context.querySelector(this.target)), Te(t);
  }
  /**
   * Returns or sets the function used to calculate the interactable's
   * element's rectangle
   *
   * @param {function} [checker] A function which returns this Interactable's
   * bounding rectangle. See {@link Interactable.getRect}
   * @return {function | object} The checker function or this Interactable
   */
  rectChecker(t) {
    return p.func(t) ? (this.getRect = (n) => {
      const i = I({}, t.apply(this, n));
      return "width" in i || (i.width = i.right - i.left, i.height = i.bottom - i.top), i;
    }, this) : t === null ? (delete this.getRect, this) : this.getRect;
  }
  /** @internal */
  _backCompatOption(t, n) {
    if (Xe(n) || p.object(n)) {
      this.options[t] = n;
      for (const i in this._actions.map)
        this.options[i][t] = n;
      return this;
    }
    return this.options[t];
  }
  /**
   * Gets or sets the origin of the Interactable's element.  The x and y
   * of the origin will be subtracted from action event coordinates.
   *
   * @param {Element | object | string} [origin] An HTML or SVG Element whose
   * rect will be used, an object eg. { x: 0, y: 0 } or string 'parent', 'self'
   * or any CSS selector
   *
   * @return {object} The current origin or this Interactable
   */
  origin(t) {
    return this._backCompatOption("origin", t);
  }
  /**
   * Returns or sets the mouse coordinate types used to calculate the
   * movement of the pointer.
   *
   * @param {string} [newValue] Use 'client' if you will be scrolling while
   * interacting; Use 'page' if you want autoScroll to work
   * @return {string | object} The current deltaSource or this Interactable
   */
  deltaSource(t) {
    return t === "page" || t === "client" ? (this.options.deltaSource = t, this) : this.options.deltaSource;
  }
  /** @internal */
  getAllElements() {
    const {
      target: t
    } = this;
    return p.string(t) ? Array.from(this._context.querySelectorAll(t)) : p.func(t) && t.getAllElements ? t.getAllElements() : p.element(t) ? [t] : [];
  }
  /**
   * Gets the selector context Node of the Interactable. The default is
   * `window.document`.
   *
   * @return {Node} The context Node of this Interactable
   */
  context() {
    return this._context;
  }
  inContext(t) {
    return this._context === t.ownerDocument || zt(this._context, t);
  }
  /** @internal */
  testIgnoreAllow(t, n, i) {
    return !this.testIgnore(t.ignoreFrom, n, i) && this.testAllow(t.allowFrom, n, i);
  }
  /** @internal */
  testAllow(t, n, i) {
    return t ? p.element(i) ? p.string(t) ? be(i, t, n) : p.element(t) ? zt(t, i) : false : false : true;
  }
  /** @internal */
  testIgnore(t, n, i) {
    return !t || !p.element(i) ? false : p.string(t) ? be(i, t, n) : p.element(t) ? zt(t, i) : false;
  }
  /**
   * Calls listeners for the given InteractEvent type bound globally
   * and directly to this Interactable
   *
   * @param {InteractEvent} iEvent The InteractEvent object to be fired on this
   * Interactable
   * @return {Interactable} this Interactable
   */
  fire(t) {
    return this.events.fire(t), this;
  }
  /** @internal */
  _onOff(t, n, i, o, s) {
    p.object(n) && !p.array(n) && (o = i, i = null);
    const a = Et(n, i, s);
    for (let l in a) {
      l === "wheel" && (l = G.wheelEvent);
      for (const c of a[l])
        qt(l, this._actions) ? this.events[t === ht.On ? "on" : "off"](l, c) : p.string(this.target) ? this._scopeEvents[t === ht.On ? "addDelegate" : "removeDelegate"](this.target, this._context, l, c, o) : this._scopeEvents[t === ht.On ? "add" : "remove"](this.target, l, c, o);
    }
    return this;
  }
  /**
   * Binds a listener for an InteractEvent, pointerEvent or DOM event.
   *
   * @param {string | array | object} types The types of events to listen
   * for
   * @param {function | array | object} [listener] The event listener function(s)
   * @param {object | boolean} [options] options object or useCapture flag for
   * addEventListener
   * @return {Interactable} This Interactable
   */
  on(t, n, i) {
    return this._onOff(ht.On, t, n, i);
  }
  /**
   * Removes an InteractEvent, pointerEvent or DOM event listener.
   *
   * @param {string | array | object} types The types of events that were
   * listened for
   * @param {function | array | object} [listener] The event listener function(s)
   * @param {object | boolean} [options] options object or useCapture flag for
   * removeEventListener
   * @return {Interactable} This Interactable
   */
  off(t, n, i) {
    return this._onOff(ht.Off, t, n, i);
  }
  /**
   * Reset the options of this Interactable
   *
   * @param {object} options The new settings to apply
   * @return {object} This Interactable
   */
  set(t) {
    const n = this._defaults;
    p.object(t) || (t = {}), this.options = Rt(n.base);
    for (const i in this._actions.methodDict) {
      const o = i, s = this._actions.methodDict[o];
      this.options[o] = {}, this.setPerAction(o, I(I({}, n.perAction), n.actions[o])), this[s](t[o]);
    }
    for (const i in t) {
      if (i === "getRect") {
        this.rectChecker(t.getRect);
        continue;
      }
      p.func(this[i]) && this[i](t[i]);
    }
    return this;
  }
  /**
   * Remove this interactable from the list of interactables and remove it's
   * action capabilities and event listeners
   */
  unset() {
    if (p.string(this.target))
      for (const t in this._scopeEvents.delegatedEvents) {
        const n = this._scopeEvents.delegatedEvents[t];
        for (let i = n.length - 1; i >= 0; i--) {
          const {
            selector: o,
            context: s,
            listeners: a
          } = n[i];
          o === this.target && s === this._context && n.splice(i, 1);
          for (let l = a.length - 1; l >= 0; l--)
            this._scopeEvents.removeDelegate(this.target, this._context, t, a[l][0], a[l][1]);
        }
      }
    else
      this._scopeEvents.remove(this.target, "all");
  }
};
var rr = class {
  constructor(t) {
    this.list = [], this.selectorMap = {}, this.scope = void 0, this.scope = t, t.addListeners({
      "interactable:unset": (n) => {
        let {
          interactable: i
        } = n;
        const {
          target: o
        } = i, s = p.string(o) ? this.selectorMap[o] : o[this.scope.id], a = re(s, (l) => l === i);
        s.splice(a, 1);
      }
    });
  }
  new(t, n) {
    n = I(n || {}, {
      actions: this.scope.actions
    });
    const i = new this.scope.Interactable(t, n, this.scope.document, this.scope.events);
    return this.scope.addDocument(i._doc), this.list.push(i), p.string(t) ? (this.selectorMap[t] || (this.selectorMap[t] = []), this.selectorMap[t].push(i)) : (i.target[this.scope.id] || Object.defineProperty(t, this.scope.id, {
      value: [],
      configurable: true
    }), t[this.scope.id].push(i)), this.scope.fire("interactable:new", {
      target: t,
      options: n,
      interactable: i,
      win: this.scope._win
    }), i;
  }
  getExisting(t, n) {
    const i = n && n.context || this.scope.document, o = p.string(t), s = o ? this.selectorMap[t] : t[this.scope.id];
    if (s)
      return Jt(s, (a) => a._context === i && (o || a.inContext(t)));
  }
  forEachMatch(t, n) {
    for (const i of this.list) {
      let o;
      if ((p.string(i.target) ? (
        // target is a selector and the element matches
        p.element(t) && Tt(t, i.target)
      ) : (
        // target is the element
        t === i.target
      )) && // the element is in context
      i.inContext(t) && (o = n(i)), o !== void 0)
        return o;
    }
  }
};
function or(e) {
  const t = (n, i) => {
    let o = e.interactables.getExisting(n, i);
    return o || (o = e.interactables.new(n, i), o.events.global = t.globalEvents), o;
  };
  return t.getPointerAverage = Mn, t.getTouchBBox = Hi, t.getTouchDistance = Li, t.getTouchAngle = Wi, t.getElementRect = Te, t.getElementClientRect = Ie, t.matchesSelector = Tt, t.closest = In, t.globalEvents = {}, t.version = "1.10.27", t.scope = e, t.use = function(n, i) {
    return this.scope.usePlugin(n, i), this;
  }, t.isSet = function(n, i) {
    return !!this.scope.interactables.get(n, i && i.context);
  }, t.on = Xt(function(i, o, s) {
    if (p.string(i) && i.search(" ") !== -1 && (i = i.trim().split(/ +/)), p.array(i)) {
      for (const a of i)
        this.on(a, o, s);
      return this;
    }
    if (p.object(i)) {
      for (const a in i)
        this.on(a, i[a], o);
      return this;
    }
    return qt(i, this.scope.actions) ? this.globalEvents[i] ? this.globalEvents[i].push(o) : this.globalEvents[i] = [o] : this.scope.events.add(this.scope.document, i, o, {
      options: s
    }), this;
  }, "The interact.on() method is being deprecated"), t.off = Xt(function(i, o, s) {
    if (p.string(i) && i.search(" ") !== -1 && (i = i.trim().split(/ +/)), p.array(i)) {
      for (const a of i)
        this.off(a, o, s);
      return this;
    }
    if (p.object(i)) {
      for (const a in i)
        this.off(a, i[a], o);
      return this;
    }
    if (qt(i, this.scope.actions)) {
      let a;
      i in this.globalEvents && (a = this.globalEvents[i].indexOf(o)) !== -1 && this.globalEvents[i].splice(a, 1);
    } else
      this.scope.events.remove(this.scope.document, i, o, s);
    return this;
  }, "The interact.off() method is being deprecated"), t.debug = function() {
    return this.scope;
  }, t.supportsTouch = function() {
    return G.supportsTouch;
  }, t.supportsPointerEvent = function() {
    return G.supportsPointerEvent;
  }, t.stop = function() {
    for (const n of this.scope.interactions.list)
      n.stop();
    return this;
  }, t.pointerMoveTolerance = function(n) {
    return p.number(n) ? (this.scope.interactions.pointerMoveTolerance = n, this) : this.scope.interactions.pointerMoveTolerance;
  }, t.addDocument = function(n, i) {
    this.scope.addDocument(n, i);
  }, t.removeDocument = function(n) {
    this.scope.removeDocument(n);
  }, t;
}
var sr = class {
  constructor() {
    this.id = `__interact_scope_${Math.floor(Math.random() * 100)}`, this.isInitialized = false, this.listenerMaps = [], this.browser = G, this.defaults = Rt(Rn), this.Eventable = zn, this.actions = {
      map: {},
      phases: {
        start: true,
        move: true,
        end: true
      },
      methodDict: {},
      phaselessTypes: {}
    }, this.interactStatic = or(this), this.InteractEvent = _e, this.Interactable = void 0, this.interactables = new rr(this), this._win = void 0, this.document = void 0, this.window = void 0, this.documents = [], this._plugins = {
      list: [],
      map: {}
    }, this.onWindowUnload = (n) => this.removeDocument(n.target);
    const t = this;
    this.Interactable = class extends ir {
      get _defaults() {
        return t.defaults;
      }
      set(n) {
        return super.set(n), t.fire("interactable:set", {
          options: n,
          interactable: this
        }), this;
      }
      unset() {
        super.unset();
        const n = t.interactables.list.indexOf(this);
        n < 0 || (t.interactables.list.splice(n, 1), t.fire("interactable:unset", {
          interactable: this
        }));
      }
    };
  }
  addListeners(t, n) {
    this.listenerMaps.push({
      id: n,
      map: t
    });
  }
  fire(t, n) {
    for (const {
      map: {
        [t]: i
      }
    } of this.listenerMaps)
      if (i && i(n, this, t) === false)
        return false;
  }
  init(t) {
    return this.isInitialized ? this : ar(this, t);
  }
  pluginIsInstalled(t) {
    const {
      id: n
    } = t;
    return n ? !!this._plugins.map[n] : this._plugins.list.indexOf(t) !== -1;
  }
  usePlugin(t, n) {
    if (!this.isInitialized)
      return this;
    if (this.pluginIsInstalled(t))
      return this;
    if (t.id && (this._plugins.map[t.id] = t), this._plugins.list.push(t), t.install && t.install(this, n), t.listeners && t.before) {
      let i = 0;
      const o = this.listenerMaps.length, s = t.before.reduce((a, l) => (a[l] = true, a[Ue(l)] = true, a), {});
      for (; i < o; i++) {
        const a = this.listenerMaps[i].id;
        if (a && (s[a] || s[Ue(a)]))
          break;
      }
      this.listenerMaps.splice(i, 0, {
        id: t.id,
        map: t.listeners
      });
    } else
      t.listeners && this.listenerMaps.push({
        id: t.id,
        map: t.listeners
      });
    return this;
  }
  addDocument(t, n) {
    if (this.getDocIndex(t) !== -1)
      return false;
    const i = It(t);
    n = n ? I({}, n) : {}, this.documents.push({
      doc: t,
      options: n
    }), this.events.documents.push(t), t !== this.document && this.events.add(i, "unload", this.onWindowUnload), this.fire("scope:add-document", {
      doc: t,
      window: i,
      scope: this,
      options: n
    });
  }
  removeDocument(t) {
    const n = this.getDocIndex(t), i = It(t), o = this.documents[n].options;
    this.events.remove(i, "unload", this.onWindowUnload), this.documents.splice(n, 1), this.events.documents.splice(n, 1), this.fire("scope:remove-document", {
      doc: t,
      window: i,
      scope: this,
      options: o
    });
  }
  getDocIndex(t) {
    for (let n = 0; n < this.documents.length; n++)
      if (this.documents[n].doc === t)
        return n;
    return -1;
  }
  getDocOptions(t) {
    const n = this.getDocIndex(t);
    return n === -1 ? null : this.documents[n].options;
  }
  now() {
    return (this.window.Date || Date).now();
  }
};
function ar(e, t) {
  return e.isInitialized = true, p.window(t) && xn(t), q.init(t), G.init(t), Ot.init(t), e.window = t, e.document = t.document, e.usePlugin(nr), e.usePlugin(ji), e;
}
function Ue(e) {
  return e && e.replace(/\/.*$/, "");
}
var $n = new sr();
var ut = $n.interactStatic;
var cr = typeof globalThis < "u" ? globalThis : window;
$n.init(cr);
function lr(e) {
  const {
    Interactable: t
    // tslint:disable-line no-shadowed-variable
  } = e;
  t.prototype.getAction = function(i, o, s, a) {
    const l = ur(this, o, s, a, e);
    return this.options.actionChecker ? this.options.actionChecker(i, o, l, this, a, s) : l;
  }, t.prototype.ignoreFrom = Xt(function(n) {
    return this._backCompatOption("ignoreFrom", n);
  }, "Interactable.ignoreFrom() has been deprecated. Use Interactble.draggable({ignoreFrom: newValue})."), t.prototype.allowFrom = Xt(function(n) {
    return this._backCompatOption("allowFrom", n);
  }, "Interactable.allowFrom() has been deprecated. Use Interactble.draggable({allowFrom: newValue})."), t.prototype.actionChecker = dr, t.prototype.styleCursor = fr;
}
function ur(e, t, n, i, o) {
  const s = e.getRect(i), a = t.buttons || {
    0: 1,
    1: 4,
    3: 8,
    4: 16
  }[t.button], l = {
    action: null,
    interactable: e,
    interaction: n,
    element: i,
    rect: s,
    buttons: a
  };
  return o.fire("auto-start:check", l), l.action;
}
function fr(e) {
  return p.bool(e) ? (this.options.styleCursor = e, this) : e === null ? (delete this.options.styleCursor, this) : this.options.styleCursor;
}
function dr(e) {
  return p.func(e) ? (this.options.actionChecker = e, this) : e === null ? (delete this.options.actionChecker, this) : this.options.actionChecker;
}
var hr = {
  id: "auto-start/interactableMethods",
  install: lr
};
function pr(e) {
  const {
    interactStatic: t,
    defaults: n
  } = e;
  e.usePlugin(hr), n.base.actionChecker = null, n.base.styleCursor = true, I(n.perAction, {
    manualStart: false,
    max: 1 / 0,
    maxPerElement: 1,
    allowFrom: null,
    ignoreFrom: null,
    // only allow left button by default
    // see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons#Return_value
    mouseButtons: 1
  }), t.maxInteractions = (i) => Bn(i, e), e.autoStart = {
    // Allow this many interactions to happen simultaneously
    maxInteractions: 1 / 0,
    withinInteractionLimit: ae,
    cursorElement: null
  };
}
function gr(e, t) {
  let {
    interaction: n,
    pointer: i,
    event: o,
    eventTarget: s
  } = e;
  if (n.interacting())
    return;
  const a = Ln(n, i, o, s, t);
  Wn(n, a, t);
}
function mr(e, t) {
  let {
    interaction: n,
    pointer: i,
    event: o,
    eventTarget: s
  } = e;
  if (n.pointerType !== "mouse" || n.pointerIsDown || n.interacting())
    return;
  const a = Ln(n, i, o, s, t);
  Wn(n, a, t);
}
function vr(e, t) {
  const {
    interaction: n
  } = e;
  if (!n.pointerIsDown || n.interacting() || !n.pointerWasMoved || !n.prepared.name)
    return;
  t.fire("autoStart:before-start", e);
  const {
    interactable: i
  } = n, o = n.prepared.name;
  o && i && (i.options[o].manualStart || !ae(i, n.element, n.prepared, t) ? n.stop() : (n.start(n.prepared, i, n.element), Nn(n, t)));
}
function yr(e, t) {
  let {
    interaction: n
  } = e;
  const {
    interactable: i
  } = n;
  i && i.options.styleCursor && we(n.element, "", t);
}
function Hn(e, t, n, i, o) {
  return t.testIgnoreAllow(t.options[e.name], n, i) && t.options[e.name].enabled && ae(t, n, e, o) ? e : null;
}
function br(e, t, n, i, o, s, a) {
  for (let l = 0, c = i.length; l < c; l++) {
    const r = i[l], f = o[l], d = r.getAction(t, n, e, f);
    if (!d)
      continue;
    const m = Hn(d, r, f, s, a);
    if (m)
      return {
        action: m,
        interactable: r,
        element: f
      };
  }
  return {
    action: null,
    interactable: null,
    element: null
  };
}
function Ln(e, t, n, i, o) {
  let s = [], a = [], l = i;
  function c(r) {
    s.push(r), a.push(l);
  }
  for (; p.element(l); ) {
    s = [], a = [], o.interactables.forEachMatch(l, c);
    const r = br(e, t, n, s, a, i, o);
    if (r.action && !r.interactable.options[r.action.name].manualStart)
      return r;
    l = gt(l);
  }
  return {
    action: null,
    interactable: null,
    element: null
  };
}
function Wn(e, t, n) {
  let {
    action: i,
    interactable: o,
    element: s
  } = t;
  i = i || {
    name: null
  }, e.interactable = o, e.element = s, _n(e.prepared, i), e.rect = o && i.name ? o.getRect(s) : null, Nn(e, n), n.fire("autoStart:prepared", {
    interaction: e
  });
}
function ae(e, t, n, i) {
  const o = e.options, s = o[n.name].max, a = o[n.name].maxPerElement, l = i.autoStart.maxInteractions;
  let c = 0, r = 0, f = 0;
  if (!(s && a && l))
    return false;
  for (const d of i.interactions.list) {
    const m = d.prepared.name;
    if (d.interacting()) {
      if (c++, c >= l)
        return false;
      if (d.interactable === e && (r += m === n.name ? 1 : 0, r >= s || d.element === t && (f++, m === n.name && f >= a)))
        return false;
    }
  }
  return l > 0;
}
function Bn(e, t) {
  return p.number(e) ? (t.autoStart.maxInteractions = e, this) : t.autoStart.maxInteractions;
}
function we(e, t, n) {
  const {
    cursorElement: i
  } = n.autoStart;
  i && i !== e && (i.style.cursor = ""), e.ownerDocument.documentElement.style.cursor = t, e.style.cursor = t, n.autoStart.cursorElement = t ? e : null;
}
function Nn(e, t) {
  const {
    interactable: n,
    element: i,
    prepared: o
  } = e;
  if (!(e.pointerType === "mouse" && n && n.options.styleCursor)) {
    t.autoStart.cursorElement && we(t.autoStart.cursorElement, "", t);
    return;
  }
  let s = "";
  if (o.name) {
    const a = n.options[o.name].cursorChecker;
    p.func(a) ? s = a(o, n, i, e._interacting) : s = t.actions.map[o.name].getCursor(o);
  }
  we(e.element, s || "", t);
}
var Pe = {
  id: "auto-start/base",
  before: ["actions"],
  install: pr,
  listeners: {
    "interactions:down": gr,
    "interactions:move": (e, t) => {
      mr(e, t), vr(e, t);
    },
    "interactions:stop": yr
  },
  maxInteractions: Bn,
  withinInteractionLimit: ae,
  validateAction: Hn
};
function xr(e, t) {
  let {
    interaction: n,
    eventTarget: i,
    dx: o,
    dy: s
  } = e;
  if (n.prepared.name !== "drag")
    return;
  const a = Math.abs(o), l = Math.abs(s), c = n.interactable.options.drag, r = c.startAxis, f = a > l ? "x" : a < l ? "y" : "xy";
  if (n.prepared.axis = c.lockAxis === "start" ? f[0] : c.lockAxis, f !== "xy" && r !== "xy" && r !== f) {
    n.prepared.name = null;
    let d = i;
    const m = function(g) {
      if (g === n.interactable)
        return;
      const b = n.interactable.options.drag;
      if (!b.manualStart && g.testIgnoreAllow(b, d, i)) {
        const C = g.getAction(n.downPointer, n.downEvent, n, d);
        if (C && C.name === "drag" && wr(f, g) && Pe.validateAction(C, g, d, i, t))
          return g;
      }
    };
    for (; p.element(d); ) {
      const g = t.interactables.forEachMatch(d, m);
      if (g) {
        n.prepared.name = "drag", n.interactable = g, n.element = d;
        break;
      }
      d = gt(d);
    }
  }
}
function wr(e, t) {
  if (!t)
    return false;
  const n = t.options.drag.startAxis;
  return e === "xy" || n === "xy" || n === e;
}
var Sr = {
  id: "auto-start/dragAxis",
  listeners: {
    "autoStart:before-start": xr
  }
};
function Er(e) {
  const {
    defaults: t
  } = e;
  e.usePlugin(Pe), t.perAction.hold = 0, t.perAction.delay = 0;
}
function he(e) {
  const t = e.prepared && e.prepared.name;
  if (!t)
    return null;
  const n = e.interactable.options;
  return n[t].hold || n[t].delay;
}
var zr = {
  id: "auto-start/hold",
  install: Er,
  listeners: {
    "interactions:new": (e) => {
      let {
        interaction: t
      } = e;
      t.autoStartHoldTimer = null;
    },
    "autoStart:prepared": (e) => {
      let {
        interaction: t
      } = e;
      const n = he(t);
      n > 0 && (t.autoStartHoldTimer = setTimeout(() => {
        t.start(t.prepared, t.interactable, t.element);
      }, n));
    },
    "interactions:move": (e) => {
      let {
        interaction: t,
        duplicate: n
      } = e;
      t.autoStartHoldTimer && t.pointerWasMoved && !n && (clearTimeout(t.autoStartHoldTimer), t.autoStartHoldTimer = null);
    },
    // prevent regular down->move autoStart
    "autoStart:before-start": (e) => {
      let {
        interaction: t
      } = e;
      he(t) > 0 && (t.prepared.name = null);
    }
  },
  getHoldDuration: he
};
var Ir = {
  id: "auto-start",
  install(e) {
    e.usePlugin(Pe), e.usePlugin(zr), e.usePlugin(Sr);
  }
};
ut.use(Ir);
function Tr(e) {
  const {
    defaults: t,
    actions: n
  } = e;
  e.autoScroll = M, M.now = () => e.now(), n.phaselessTypes.autoscroll = true, t.perAction.autoScroll = M.defaults;
}
var M = {
  defaults: {
    enabled: false,
    margin: 60,
    // the item that is scrolled (Window or HTMLElement)
    container: null,
    // the scroll speed in pixels per second
    speed: 300
  },
  now: Date.now,
  interaction: null,
  i: 0,
  // the handle returned by window.setInterval
  // Direction each pulse is to scroll in
  x: 0,
  y: 0,
  isScrolling: false,
  prevTime: 0,
  margin: 0,
  speed: 0,
  start(e) {
    M.isScrolling = true, Ot.cancel(M.i), e.autoScroll = M, M.interaction = e, M.prevTime = M.now(), M.i = Ot.request(M.scroll);
  },
  stop() {
    M.isScrolling = false, M.interaction && (M.interaction.autoScroll = null), Ot.cancel(M.i);
  },
  // scroll the window by the values in scroll.x/y
  scroll() {
    const {
      interaction: e
    } = M, {
      interactable: t,
      element: n
    } = e, i = e.prepared.name, o = t.options[i].autoScroll, s = Ve(o.container, t, n), a = M.now(), l = (a - M.prevTime) / 1e3, c = o.speed * l;
    if (c >= 1) {
      const r = {
        x: M.x * c,
        y: M.y * c
      };
      if (r.x || r.y) {
        const f = Ke(s);
        p.window(s) ? s.scrollBy(r.x, r.y) : s && (s.scrollLeft += r.x, s.scrollTop += r.y);
        const d = Ke(s), m = {
          x: d.x - f.x,
          y: d.y - f.y
        };
        (m.x || m.y) && t.fire({
          type: "autoscroll",
          target: n,
          interactable: t,
          delta: m,
          interaction: e,
          container: s
        });
      }
      M.prevTime = a;
    }
    M.isScrolling && (Ot.cancel(M.i), M.i = Ot.request(M.scroll));
  },
  check(e, t) {
    var n;
    return (n = e.options[t].autoScroll) == null ? void 0 : n.enabled;
  },
  onInteractionMove(e) {
    let {
      interaction: t,
      pointer: n
    } = e;
    if (!(t.interacting() && M.check(t.interactable, t.prepared.name)))
      return;
    if (t.simulation) {
      M.x = M.y = 0;
      return;
    }
    let i, o, s, a;
    const {
      interactable: l,
      element: c
    } = t, r = t.prepared.name, f = l.options[r].autoScroll, d = Ve(f.container, l, c);
    if (p.window(d))
      a = n.clientX < M.margin, i = n.clientY < M.margin, o = n.clientX > d.innerWidth - M.margin, s = n.clientY > d.innerHeight - M.margin;
    else {
      const m = Ie(d);
      a = n.clientX < m.left + M.margin, i = n.clientY < m.top + M.margin, o = n.clientX > m.right - M.margin, s = n.clientY > m.bottom - M.margin;
    }
    M.x = o ? 1 : a ? -1 : 0, M.y = s ? 1 : i ? -1 : 0, M.isScrolling || (M.margin = f.margin, M.speed = f.speed, M.start(t));
  }
};
function Ve(e, t, n) {
  return (p.string(e) ? Pn(e, t, n) : e) || It(n);
}
function Ke(e) {
  return p.window(e) && (e = window.document.body), {
    x: e.scrollLeft,
    y: e.scrollTop
  };
}
var Dr = {
  id: "auto-scroll",
  install: Tr,
  listeners: {
    "interactions:new": (e) => {
      let {
        interaction: t
      } = e;
      t.autoScroll = null;
    },
    "interactions:destroy": (e) => {
      let {
        interaction: t
      } = e;
      t.autoScroll = null, M.stop(), M.interaction && (M.interaction = null);
    },
    "interactions:stop": M.stop,
    "interactions:action-move": (e) => M.onInteractionMove(e)
  }
};
ut.use(Dr);
function Mr(e) {
  const {
    actions: t,
    Interactable: n,
    defaults: i
  } = e;
  n.prototype.draggable = Zt.draggable, t.map.drag = Zt, t.methodDict.drag = "draggable", i.actions.drag = Zt.defaults;
}
function pe(e) {
  let {
    interaction: t
  } = e;
  if (t.prepared.name !== "drag")
    return;
  const n = t.prepared.axis;
  n === "x" ? (t.coords.cur.page.y = t.coords.start.page.y, t.coords.cur.client.y = t.coords.start.client.y, t.coords.velocity.client.y = 0, t.coords.velocity.page.y = 0) : n === "y" && (t.coords.cur.page.x = t.coords.start.page.x, t.coords.cur.client.x = t.coords.start.client.x, t.coords.velocity.client.x = 0, t.coords.velocity.page.x = 0);
}
function Je(e) {
  let {
    iEvent: t,
    interaction: n
  } = e;
  if (n.prepared.name !== "drag")
    return;
  const i = n.prepared.axis;
  if (i === "x" || i === "y") {
    const o = i === "x" ? "y" : "x";
    t.page[o] = n.coords.start.page[o], t.client[o] = n.coords.start.client[o], t.delta[o] = 0;
  }
}
var Cr = function(t) {
  return p.object(t) ? (this.options.drag.enabled = t.enabled !== false, this.setPerAction("drag", t), this.setOnEvents("drag", t), /^(xy|x|y|start)$/.test(t.lockAxis) && (this.options.drag.lockAxis = t.lockAxis), /^(xy|x|y)$/.test(t.startAxis) && (this.options.drag.startAxis = t.startAxis), this) : p.bool(t) ? (this.options.drag.enabled = t, this) : this.options.drag;
};
var Zt = {
  id: "actions/drag",
  install: Mr,
  listeners: {
    "interactions:before-action-move": pe,
    "interactions:action-resume": pe,
    // dragmove
    "interactions:action-move": Je,
    "auto-start:check": (e) => {
      const {
        interaction: t,
        interactable: n,
        buttons: i
      } = e, o = n.options.drag;
      if (!(!(o && o.enabled) || // check mouseButton setting if the pointer is down
      t.pointerIsDown && /mouse|pointer/.test(t.pointerType) && !(i & n.options.drag.mouseButtons)))
        return e.action = {
          name: "drag",
          axis: o.lockAxis === "start" ? o.startAxis : o.lockAxis
        }, false;
    }
  },
  draggable: Cr,
  beforeMove: pe,
  move: Je,
  defaults: {
    startAxis: "xy",
    lockAxis: "xy"
  },
  getCursor() {
    return "move";
  },
  filterEventType: (e) => e.search("drag") === 0
};
ut.use(Zt);
function _r(e) {
  const {
    actions: t,
    browser: n,
    Interactable: i,
    // tslint:disable-line no-shadowed-variable
    defaults: o
  } = e;
  lt.cursors = kr(n), lt.defaultMargin = n.supportsTouch || n.supportsPointerEvent ? 20 : 10, i.prototype.resizable = function(s) {
    return Or(this, s, e);
  }, t.map.resize = lt, t.methodDict.resize = "resizable", o.actions.resize = lt.defaults;
}
function Pr(e) {
  const {
    interaction: t,
    interactable: n,
    element: i,
    rect: o,
    buttons: s
  } = e;
  if (!o)
    return;
  const a = I({}, t.coords.cur.page), l = n.options.resize;
  if (!(!(l && l.enabled) || // check mouseButton setting if the pointer is down
  t.pointerIsDown && /mouse|pointer/.test(t.pointerType) && !(s & l.mouseButtons))) {
    if (p.object(l.edges)) {
      const c = {
        left: false,
        right: false,
        top: false,
        bottom: false
      };
      for (const r in c)
        c[r] = Rr(r, l.edges[r], a, t._latestPointer.eventTarget, i, o, l.margin || lt.defaultMargin);
      c.left = c.left && !c.right, c.top = c.top && !c.bottom, (c.left || c.right || c.top || c.bottom) && (e.action = {
        name: "resize",
        edges: c
      });
    } else {
      const c = l.axis !== "y" && a.x > o.right - lt.defaultMargin, r = l.axis !== "x" && a.y > o.bottom - lt.defaultMargin;
      (c || r) && (e.action = {
        name: "resize",
        axes: (c ? "x" : "") + (r ? "y" : "")
      });
    }
    return e.action ? false : void 0;
  }
}
function Or(e, t, n) {
  return p.object(t) ? (e.options.resize.enabled = t.enabled !== false, e.setPerAction("resize", t), e.setOnEvents("resize", t), p.string(t.axis) && /^x$|^y$|^xy$/.test(t.axis) ? e.options.resize.axis = t.axis : t.axis === null && (e.options.resize.axis = n.defaults.actions.resize.axis), p.bool(t.preserveAspectRatio) ? e.options.resize.preserveAspectRatio = t.preserveAspectRatio : p.bool(t.square) && (e.options.resize.square = t.square), e) : p.bool(t) ? (e.options.resize.enabled = t, e) : e.options.resize;
}
function Rr(e, t, n, i, o, s, a) {
  if (!t)
    return false;
  if (t === true) {
    const l = p.number(s.width) ? s.width : s.right - s.left, c = p.number(s.height) ? s.height : s.bottom - s.top;
    if (a = Math.min(a, Math.abs((e === "left" || e === "right" ? l : c) / 2)), l < 0 && (e === "left" ? e = "right" : e === "right" && (e = "left")), c < 0 && (e === "top" ? e = "bottom" : e === "bottom" && (e = "top")), e === "left") {
      const r = l >= 0 ? s.left : s.right;
      return n.x < r + a;
    }
    if (e === "top") {
      const r = c >= 0 ? s.top : s.bottom;
      return n.y < r + a;
    }
    if (e === "right")
      return n.x > (l >= 0 ? s.right : s.left) - a;
    if (e === "bottom")
      return n.y > (c >= 0 ? s.bottom : s.top) - a;
  }
  return p.element(i) ? p.element(t) ? (
    // the value is an element to use as a resize handle
    t === i
  ) : (
    // otherwise check if element matches value as selector
    be(i, t, o)
  ) : false;
}
function kr(e) {
  return e.isIe9 ? {
    x: "e-resize",
    y: "s-resize",
    xy: "se-resize",
    top: "n-resize",
    left: "w-resize",
    bottom: "s-resize",
    right: "e-resize",
    topleft: "se-resize",
    bottomright: "se-resize",
    topright: "ne-resize",
    bottomleft: "ne-resize"
  } : {
    x: "ew-resize",
    y: "ns-resize",
    xy: "nwse-resize",
    top: "ns-resize",
    left: "ew-resize",
    bottom: "ns-resize",
    right: "ew-resize",
    topleft: "nwse-resize",
    bottomright: "nwse-resize",
    topright: "nesw-resize",
    bottomleft: "nesw-resize"
  };
}
function Ar(e) {
  let {
    iEvent: t,
    interaction: n
  } = e;
  if (n.prepared.name !== "resize" || !n.prepared.edges)
    return;
  const i = t, o = n.rect;
  n._rects = {
    start: I({}, o),
    corrected: I({}, o),
    previous: I({}, o),
    delta: {
      left: 0,
      right: 0,
      width: 0,
      top: 0,
      bottom: 0,
      height: 0
    }
  }, i.edges = n.prepared.edges, i.rect = n._rects.corrected, i.deltaRect = n._rects.delta;
}
function $r(e) {
  let {
    iEvent: t,
    interaction: n
  } = e;
  if (n.prepared.name !== "resize" || !n.prepared.edges)
    return;
  const i = t, s = n.interactable.options.resize.invert, a = s === "reposition" || s === "negate", l = n.rect, {
    start: c,
    corrected: r,
    delta: f,
    previous: d
  } = n._rects;
  if (I(d, r), a) {
    if (I(r, l), s === "reposition") {
      if (r.top > r.bottom) {
        const m = r.top;
        r.top = r.bottom, r.bottom = m;
      }
      if (r.left > r.right) {
        const m = r.left;
        r.left = r.right, r.right = m;
      }
    }
  } else
    r.top = Math.min(l.top, c.bottom), r.bottom = Math.max(l.bottom, c.top), r.left = Math.min(l.left, c.right), r.right = Math.max(l.right, c.left);
  r.width = r.right - r.left, r.height = r.bottom - r.top;
  for (const m in r)
    f[m] = r[m] - d[m];
  i.edges = n.prepared.edges, i.rect = r, i.deltaRect = f;
}
function Hr(e) {
  let {
    iEvent: t,
    interaction: n
  } = e;
  if (n.prepared.name !== "resize" || !n.prepared.edges)
    return;
  const i = t;
  i.edges = n.prepared.edges, i.rect = n._rects.corrected, i.deltaRect = n._rects.delta;
}
function Ze(e) {
  let {
    iEvent: t,
    interaction: n
  } = e;
  if (n.prepared.name !== "resize" || !n.resizeAxes)
    return;
  const i = n.interactable.options, o = t;
  i.resize.square ? (n.resizeAxes === "y" ? o.delta.x = o.delta.y : o.delta.y = o.delta.x, o.axes = "xy") : (o.axes = n.resizeAxes, n.resizeAxes === "x" ? o.delta.y = 0 : n.resizeAxes === "y" && (o.delta.x = 0));
}
var lt = {
  id: "actions/resize",
  before: ["actions/drag"],
  install: _r,
  listeners: {
    "interactions:new": (e) => {
      let {
        interaction: t
      } = e;
      t.resizeAxes = "xy";
    },
    "interactions:action-start": (e) => {
      Ar(e), Ze(e);
    },
    "interactions:action-move": (e) => {
      $r(e), Ze(e);
    },
    "interactions:action-end": Hr,
    "auto-start:check": Pr
  },
  defaults: {
    square: false,
    preserveAspectRatio: false,
    axis: "xy",
    // use default margin
    margin: NaN,
    // object with props left, right, top, bottom which are
    // true/false values to resize when the pointer is over that edge,
    // CSS selectors to match the handles for each direction
    // or the Elements for each handle
    edges: null,
    // a value of 'none' will limit the resize rect to a minimum of 0x0
    // 'negate' will alow the rect to have negative width/height
    // 'reposition' will keep the width/height positive by swapping
    // the top and bottom edges and/or swapping the left and right edges
    invert: "none"
  },
  cursors: null,
  getCursor(e) {
    let {
      edges: t,
      axis: n,
      name: i
    } = e;
    const o = lt.cursors;
    let s = null;
    if (n)
      s = o[i + n];
    else if (t) {
      let a = "";
      for (const l of ["top", "bottom", "left", "right"])
        t[l] && (a += l);
      s = o[a];
    }
    return s;
  },
  filterEventType: (e) => e.search("resize") === 0,
  defaultMargin: null
};
ut.use(lt);
var Lr = () => {
};
var Wr = () => {
};
var Br = (e) => {
  const t = [["x", "y"], ["left", "top"], ["right", "bottom"], ["width", "height"]].filter((i) => {
    let [o, s] = i;
    return o in e || s in e;
  }), n = (i, o) => {
    const {
      range: s,
      limits: a = {
        left: -1 / 0,
        right: 1 / 0,
        top: -1 / 0,
        bottom: 1 / 0
      },
      offset: l = {
        x: 0,
        y: 0
      }
    } = e, c = {
      range: s,
      grid: e,
      x: null,
      y: null
    };
    for (const [r, f] of t) {
      const d = Math.round((i - l.x) / e[r]), m = Math.round((o - l.y) / e[f]);
      c[r] = Math.max(a.left, Math.min(a.right, d * e[r] + l.x)), c[f] = Math.max(a.top, Math.min(a.bottom, m * e[f] + l.y));
    }
    return c;
  };
  return n.grid = e, n.coordFields = t, n;
};
var Nr = Object.freeze({
  __proto__: null,
  edgeTarget: Lr,
  elements: Wr,
  grid: Br
});
var Fr = {
  id: "snappers",
  install(e) {
    const {
      interactStatic: t
    } = e;
    t.snappers = I(t.snappers || {}, Nr), t.createSnapGrid = t.snappers.grid;
  }
};
var Fn = class {
  constructor(t) {
    this.states = [], this.startOffset = {
      left: 0,
      right: 0,
      top: 0,
      bottom: 0
    }, this.startDelta = void 0, this.result = void 0, this.endResult = void 0, this.startEdges = void 0, this.edges = void 0, this.interaction = void 0, this.interaction = t, this.result = Kt(), this.edges = {
      left: false,
      right: false,
      top: false,
      bottom: false
    };
  }
  start(t, n) {
    let {
      phase: i
    } = t;
    const {
      interaction: o
    } = this, s = jr(o);
    this.prepareStates(s), this.startEdges = I({}, o.edges), this.edges = I({}, this.startEdges), this.startOffset = Xr(o.rect, n), this.startDelta = {
      x: 0,
      y: 0
    };
    const a = this.fillArg({
      phase: i,
      pageCoords: n,
      preEnd: false
    });
    return this.result = Kt(), this.startAll(a), this.result = this.setAll(a);
  }
  fillArg(t) {
    const {
      interaction: n
    } = this;
    return t.interaction = n, t.interactable = n.interactable, t.element = n.element, t.rect || (t.rect = n.rect), t.edges || (t.edges = this.startEdges), t.startOffset = this.startOffset, t;
  }
  startAll(t) {
    for (const n of this.states)
      n.methods.start && (t.state = n, n.methods.start(t));
  }
  setAll(t) {
    const {
      phase: n,
      preEnd: i,
      skipModifiers: o,
      rect: s,
      edges: a
    } = t;
    t.coords = I({}, t.pageCoords), t.rect = I({}, s), t.edges = I({}, a);
    const l = o ? this.states.slice(o) : this.states, c = Kt(t.coords, t.rect);
    for (const m of l) {
      var r;
      const {
        options: g
      } = m, b = I({}, t.coords);
      let C = null;
      (r = m.methods) != null && r.set && this.shouldDo(g, i, n) && (t.state = m, C = m.methods.set(t), Me(t.edges, t.rect, {
        x: t.coords.x - b.x,
        y: t.coords.y - b.y
      })), c.eventProps.push(C);
    }
    I(this.edges, t.edges), c.delta.x = t.coords.x - t.pageCoords.x, c.delta.y = t.coords.y - t.pageCoords.y, c.rectDelta.left = t.rect.left - s.left, c.rectDelta.right = t.rect.right - s.right, c.rectDelta.top = t.rect.top - s.top, c.rectDelta.bottom = t.rect.bottom - s.bottom;
    const f = this.result.coords, d = this.result.rect;
    if (f && d) {
      const m = c.rect.left !== d.left || c.rect.right !== d.right || c.rect.top !== d.top || c.rect.bottom !== d.bottom;
      c.changed = m || f.x !== c.coords.x || f.y !== c.coords.y;
    }
    return c;
  }
  applyToInteraction(t) {
    const {
      interaction: n
    } = this, {
      phase: i
    } = t, o = n.coords.cur, s = n.coords.start, {
      result: a,
      startDelta: l
    } = this, c = a.delta;
    i === "start" && I(this.startDelta, a.delta);
    for (const [d, m] of [[s, l], [o, c]])
      d.page.x += m.x, d.page.y += m.y, d.client.x += m.x, d.client.y += m.y;
    const {
      rectDelta: r
    } = this.result, f = t.rect || n.rect;
    f.left += r.left, f.right += r.right, f.top += r.top, f.bottom += r.bottom, f.width = f.right - f.left, f.height = f.bottom - f.top;
  }
  setAndApply(t) {
    const {
      interaction: n
    } = this, {
      phase: i,
      preEnd: o,
      skipModifiers: s
    } = t, a = this.setAll(this.fillArg({
      preEnd: o,
      phase: i,
      pageCoords: t.modifiedCoords || n.coords.cur.page
    }));
    if (this.result = a, !a.changed && (!s || s < this.states.length) && n.interacting())
      return false;
    if (t.modifiedCoords) {
      const {
        page: l
      } = n.coords.cur, c = {
        x: t.modifiedCoords.x - l.x,
        y: t.modifiedCoords.y - l.y
      };
      a.coords.x += c.x, a.coords.y += c.y, a.delta.x += c.x, a.delta.y += c.y;
    }
    this.applyToInteraction(t);
  }
  beforeEnd(t) {
    const {
      interaction: n,
      event: i
    } = t, o = this.states;
    if (!o || !o.length)
      return;
    let s = false;
    for (const a of o) {
      t.state = a;
      const {
        options: l,
        methods: c
      } = a, r = c.beforeEnd && c.beforeEnd(t);
      if (r)
        return this.endResult = r, false;
      s = s || !s && this.shouldDo(l, true, t.phase, true);
    }
    s && n.move({
      event: i,
      preEnd: true
    });
  }
  stop(t) {
    const {
      interaction: n
    } = t;
    if (!this.states || !this.states.length)
      return;
    const i = I({
      states: this.states,
      interactable: n.interactable,
      element: n.element,
      rect: null
    }, t);
    this.fillArg(i);
    for (const o of this.states)
      i.state = o, o.methods.stop && o.methods.stop(i);
    this.states = null, this.endResult = null;
  }
  prepareStates(t) {
    this.states = [];
    for (let n = 0; n < t.length; n++) {
      const {
        options: i,
        methods: o,
        name: s
      } = t[n];
      this.states.push({
        options: i,
        methods: o,
        index: n,
        name: s
      });
    }
    return this.states;
  }
  restoreInteractionCoords(t) {
    let {
      interaction: {
        coords: n,
        rect: i,
        modification: o
      }
    } = t;
    if (!o.result)
      return;
    const {
      startDelta: s
    } = o, {
      delta: a,
      rectDelta: l
    } = o.result, c = [[n.start, s], [n.cur, a]];
    for (const [r, f] of c)
      r.page.x -= f.x, r.page.y -= f.y, r.client.x -= f.x, r.client.y -= f.y;
    i.left -= l.left, i.right -= l.right, i.top -= l.top, i.bottom -= l.bottom;
  }
  shouldDo(t, n, i, o) {
    return (
      // ignore disabled modifiers
      !(!t || t.enabled === false || // check if we require endOnly option to fire move before end
      o && !t.endOnly || // don't apply endOnly modifiers when not ending
      t.endOnly && !n || // check if modifier should run be applied on start
      i === "start" && !t.setStart)
    );
  }
  copyFrom(t) {
    this.startOffset = t.startOffset, this.startDelta = t.startDelta, this.startEdges = t.startEdges, this.edges = t.edges, this.states = t.states.map((n) => Rt(n)), this.result = Kt(I({}, t.result.coords), I({}, t.result.rect));
  }
  destroy() {
    for (const t in this)
      this[t] = null;
  }
};
function Kt(e, t) {
  return {
    rect: t,
    coords: e,
    delta: {
      x: 0,
      y: 0
    },
    rectDelta: {
      left: 0,
      right: 0,
      top: 0,
      bottom: 0
    },
    eventProps: [],
    changed: true
  };
}
function jr(e) {
  const t = e.interactable.options[e.prepared.name], n = t.modifiers;
  return n && n.length ? n : ["snap", "snapSize", "snapEdges", "restrict", "restrictEdges", "restrictSize"].map((i) => {
    const o = t[i];
    return o && o.enabled && {
      options: o,
      methods: o._methods
    };
  }).filter((i) => !!i);
}
function Xr(e, t) {
  return e ? {
    left: t.x - e.left,
    top: t.y - e.top,
    right: e.right - t.x,
    bottom: e.bottom - t.y
  } : {
    left: 0,
    top: 0,
    right: 0,
    bottom: 0
  };
}
function mt(e, t) {
  const {
    defaults: n
  } = e, i = {
    start: e.start,
    set: e.set,
    beforeEnd: e.beforeEnd,
    stop: e.stop
  }, o = (s) => {
    const a = s || {};
    a.enabled = a.enabled !== false;
    for (const c in n)
      c in a || (a[c] = n[c]);
    const l = {
      options: a,
      methods: i,
      name: t,
      enable: () => (a.enabled = true, l),
      disable: () => (a.enabled = false, l)
    };
    return l;
  };
  return t && typeof t == "string" && (o._defaults = n, o._methods = i), o;
}
function ge(e) {
  let {
    iEvent: t,
    interaction: n
  } = e;
  const i = n.modification.result;
  i && (t.modifiers = i.eventProps);
}
var Yr = {
  id: "modifiers/base",
  before: ["actions"],
  install: (e) => {
    e.defaults.perAction.modifiers = [];
  },
  listeners: {
    "interactions:new": (e) => {
      let {
        interaction: t
      } = e;
      t.modification = new Fn(t);
    },
    "interactions:before-action-start": (e) => {
      const {
        interaction: t
      } = e, n = e.interaction.modification;
      n.start(e, t.coords.start.page), t.edges = n.edges, n.applyToInteraction(e);
    },
    "interactions:before-action-move": (e) => {
      const {
        interaction: t
      } = e, {
        modification: n
      } = t, i = n.setAndApply(e);
      return t.edges = n.edges, i;
    },
    "interactions:before-action-end": (e) => {
      const {
        interaction: t
      } = e, {
        modification: n
      } = t, i = n.beforeEnd(e);
      return t.edges = n.startEdges, i;
    },
    "interactions:action-start": ge,
    "interactions:action-move": ge,
    "interactions:action-end": ge,
    "interactions:after-action-start": (e) => e.interaction.modification.restoreInteractionCoords(e),
    "interactions:after-action-move": (e) => e.interaction.modification.restoreInteractionCoords(e),
    "interactions:stop": (e) => e.interaction.modification.stop(e)
  }
};
var qr = {
  start(e) {
    const {
      state: t,
      rect: n,
      edges: i,
      pageCoords: o
    } = e;
    let {
      ratio: s,
      enabled: a
    } = t.options;
    const {
      equalDelta: l,
      modifiers: c
    } = t.options;
    s === "preserve" && (s = n.width / n.height), t.startCoords = I({}, o), t.startRect = I({}, n), t.ratio = s, t.equalDelta = l;
    const r = t.linkedEdges = {
      top: i.top || i.left && !i.bottom,
      left: i.left || i.top && !i.right,
      bottom: i.bottom || i.right && !i.top,
      right: i.right || i.bottom && !i.left
    };
    if (t.xIsPrimaryAxis = !!(i.left || i.right), t.equalDelta) {
      const d = (r.left ? 1 : -1) * (r.top ? 1 : -1);
      t.edgeSign = {
        x: d,
        y: d
      };
    } else
      t.edgeSign = {
        x: r.left ? -1 : 1,
        y: r.top ? -1 : 1
      };
    if (a !== false && I(i, r), !(c != null && c.length))
      return;
    const f = new Fn(e.interaction);
    f.copyFrom(e.interaction.modification), f.prepareStates(c), t.subModification = f, f.startAll({
      ...e
    });
  },
  set(e) {
    const {
      state: t,
      rect: n,
      coords: i
    } = e, {
      linkedEdges: o
    } = t, s = I({}, i), a = t.equalDelta ? Gr : Ur;
    if (I(e.edges, o), a(t, t.xIsPrimaryAxis, i, n), !t.subModification)
      return null;
    const l = I({}, n);
    Me(o, l, {
      x: i.x - s.x,
      y: i.y - s.y
    });
    const c = t.subModification.setAll({
      ...e,
      rect: l,
      edges: o,
      pageCoords: i,
      prevCoords: i,
      prevRect: l
    }), {
      delta: r
    } = c;
    if (c.changed) {
      const f = Math.abs(r.x) > Math.abs(r.y);
      a(t, f, c.coords, c.rect), I(i, c.coords);
    }
    return c.eventProps;
  },
  defaults: {
    ratio: "preserve",
    equalDelta: false,
    modifiers: [],
    enabled: false
  }
};
function Gr(e, t, n) {
  let {
    startCoords: i,
    edgeSign: o
  } = e;
  t ? n.y = i.y + (n.x - i.x) * o.y : n.x = i.x + (n.y - i.y) * o.x;
}
function Ur(e, t, n, i) {
  let {
    startRect: o,
    startCoords: s,
    ratio: a,
    edgeSign: l
  } = e;
  if (t) {
    const c = i.width / a;
    n.y = s.y + (c - o.height) * l.y;
  } else {
    const c = i.height * a;
    n.x = s.x + (c - o.width) * l.x;
  }
}
var Vr = mt(qr, "aspectRatio");
function Kr(e) {
  let {
    rect: t,
    startOffset: n,
    state: i,
    interaction: o,
    pageCoords: s
  } = e;
  const {
    options: a
  } = i, {
    elementRect: l
  } = a, c = I({
    left: 0,
    top: 0,
    right: 0,
    bottom: 0
  }, a.offset || {});
  if (t && l) {
    const r = Dt(a.restriction, o, s);
    if (r) {
      const f = r.right - r.left - t.width, d = r.bottom - r.top - t.height;
      f < 0 && (c.left += f, c.right += f), d < 0 && (c.top += d, c.bottom += d);
    }
    c.left += n.left - t.width * l.left, c.top += n.top - t.height * l.top, c.right += n.right - t.width * (1 - l.right), c.bottom += n.bottom - t.height * (1 - l.bottom);
  }
  i.offset = c;
}
function Jr(e) {
  let {
    coords: t,
    interaction: n,
    state: i
  } = e;
  const {
    options: o,
    offset: s
  } = i, a = Dt(o.restriction, n, t);
  if (!a)
    return;
  const l = Vi(a);
  t.x = Math.max(Math.min(l.right - s.right, t.x), l.left + s.left), t.y = Math.max(Math.min(l.bottom - s.bottom, t.y), l.top + s.top);
}
function Dt(e, t, n) {
  return p.func(e) ? Yt(e, t.interactable, t.element, [n.x, n.y, t]) : Yt(e, t.interactable, t.element);
}
var Zr = {
  restriction: null,
  elementRect: null,
  offset: null,
  endOnly: false,
  enabled: false
};
var ee = {
  start: Kr,
  set: Jr,
  defaults: Zr
};
var Qr = mt(ee, "restrict");
var jn = {
  top: 1 / 0,
  left: 1 / 0,
  bottom: -1 / 0,
  right: -1 / 0
};
var Xn = {
  top: -1 / 0,
  left: -1 / 0,
  bottom: 1 / 0,
  right: 1 / 0
};
function to(e) {
  let {
    interaction: t,
    startOffset: n,
    state: i
  } = e;
  const {
    options: o
  } = i;
  let s;
  if (o) {
    const a = Dt(o.offset, t, t.coords.start.page);
    s = se(a);
  }
  s = s || {
    x: 0,
    y: 0
  }, i.offset = {
    top: s.y + n.top,
    left: s.x + n.left,
    bottom: s.y - n.bottom,
    right: s.x - n.right
  };
}
function eo(e) {
  let {
    coords: t,
    edges: n,
    interaction: i,
    state: o
  } = e;
  const {
    offset: s,
    options: a
  } = o;
  if (!n)
    return;
  const l = I({}, t), c = Dt(a.inner, i, l) || {}, r = Dt(a.outer, i, l) || {};
  Qe(c, jn), Qe(r, Xn), n.top ? t.y = Math.min(Math.max(r.top + s.top, l.y), c.top + s.top) : n.bottom && (t.y = Math.max(Math.min(r.bottom + s.bottom, l.y), c.bottom + s.bottom)), n.left ? t.x = Math.min(Math.max(r.left + s.left, l.x), c.left + s.left) : n.right && (t.x = Math.max(Math.min(r.right + s.right, l.x), c.right + s.right));
}
function Qe(e, t) {
  for (const n of ["top", "left", "bottom", "right"])
    n in e || (e[n] = t[n]);
  return e;
}
var no = {
  inner: null,
  outer: null,
  offset: null,
  endOnly: false,
  enabled: false
};
var Nt = {
  noInner: jn,
  noOuter: Xn,
  start: to,
  set: eo,
  defaults: no
};
var io = mt(Nt, "restrictEdges");
var ro = I({
  get elementRect() {
    return {
      top: 0,
      left: 0,
      bottom: 1,
      right: 1
    };
  },
  set elementRect(e) {
  }
}, ee.defaults);
var oo = {
  start: ee.start,
  set: ee.set,
  defaults: ro
};
var so = mt(oo, "restrictRect");
var ao = {
  width: -1 / 0,
  height: -1 / 0
};
var co = {
  width: 1 / 0,
  height: 1 / 0
};
function lo(e) {
  return Nt.start(e);
}
function uo(e) {
  const {
    interaction: t,
    state: n,
    rect: i,
    edges: o
  } = e, {
    options: s
  } = n;
  if (!o)
    return;
  const a = Ye(Dt(s.min, t, e.coords)) || ao, l = Ye(Dt(s.max, t, e.coords)) || co;
  n.options = {
    endOnly: s.endOnly,
    inner: I({}, Nt.noInner),
    outer: I({}, Nt.noOuter)
  }, o.top ? (n.options.inner.top = i.bottom - a.height, n.options.outer.top = i.bottom - l.height) : o.bottom && (n.options.inner.bottom = i.top + a.height, n.options.outer.bottom = i.top + l.height), o.left ? (n.options.inner.left = i.right - a.width, n.options.outer.left = i.right - l.width) : o.right && (n.options.inner.right = i.left + a.width, n.options.outer.right = i.left + l.width), Nt.set(e), n.options = s;
}
var fo = {
  min: null,
  max: null,
  endOnly: false,
  enabled: false
};
var ho = {
  start: lo,
  set: uo,
  defaults: fo
};
var po = mt(ho, "restrictSize");
function go(e) {
  const {
    interaction: t,
    interactable: n,
    element: i,
    rect: o,
    state: s,
    startOffset: a
  } = e, {
    options: l
  } = s, c = l.offsetWithOrigin ? vo(e) : {
    x: 0,
    y: 0
  };
  let r;
  if (l.offset === "startCoords")
    r = {
      x: t.coords.start.page.x,
      y: t.coords.start.page.y
    };
  else {
    const d = Yt(l.offset, n, i, [t]);
    r = se(d) || {
      x: 0,
      y: 0
    }, r.x += c.x, r.y += c.y;
  }
  const {
    relativePoints: f
  } = l;
  s.offsets = o && f && f.length ? f.map((d, m) => ({
    index: m,
    relativePoint: d,
    x: a.left - o.width * d.x + r.x,
    y: a.top - o.height * d.y + r.y
  })) : [{
    index: 0,
    relativePoint: null,
    x: r.x,
    y: r.y
  }];
}
function mo(e) {
  const {
    interaction: t,
    coords: n,
    state: i
  } = e, {
    options: o,
    offsets: s
  } = i, a = Ce(t.interactable, t.element, t.prepared.name), l = I({}, n), c = [];
  o.offsetWithOrigin || (l.x -= a.x, l.y -= a.y);
  for (const f of s) {
    const d = l.x - f.x, m = l.y - f.y;
    for (let g = 0, b = o.targets.length; g < b; g++) {
      const C = o.targets[g];
      let k;
      p.func(C) ? k = C(d, m, t._proxy, f, g) : k = C, k && c.push({
        x: (p.number(k.x) ? k.x : d) + f.x,
        y: (p.number(k.y) ? k.y : m) + f.y,
        range: p.number(k.range) ? k.range : o.range,
        source: C,
        index: g,
        offset: f
      });
    }
  }
  const r = {
    target: null,
    inRange: false,
    distance: 0,
    range: 0,
    delta: {
      x: 0,
      y: 0
    }
  };
  for (const f of c) {
    const d = f.range, m = f.x - l.x, g = f.y - l.y, b = oe(m, g);
    let C = b <= d;
    d === 1 / 0 && r.inRange && r.range !== 1 / 0 && (C = false), (!r.target || (C ? (
      // is the closest target in range?
      r.inRange && d !== 1 / 0 ? (
        // the pointer is relatively deeper in this target
        b / d < r.distance / r.range
      ) : (
        // this target has Infinite range and the closest doesn't
        d === 1 / 0 && r.range !== 1 / 0 || // OR this target is closer that the previous closest
        b < r.distance
      )
    ) : (
      // The other is not in range and the pointer is closer to this target
      !r.inRange && b < r.distance
    ))) && (r.target = f, r.distance = b, r.range = d, r.inRange = C, r.delta.x = m, r.delta.y = g);
  }
  return r.inRange && (n.x = r.target.x, n.y = r.target.y), i.closest = r, r;
}
function vo(e) {
  const {
    element: t
  } = e.interaction;
  return se(Yt(e.state.options.origin, null, null, [t])) || Ce(e.interactable, t, e.interaction.prepared.name);
}
var yo = {
  range: 1 / 0,
  targets: null,
  offset: null,
  offsetWithOrigin: true,
  origin: null,
  relativePoints: null,
  endOnly: false,
  enabled: false
};
var Oe = {
  start: go,
  set: mo,
  defaults: yo
};
var bo = mt(Oe, "snap");
function xo(e) {
  const {
    state: t,
    edges: n
  } = e, {
    options: i
  } = t;
  if (!n)
    return null;
  e.state = {
    options: {
      targets: null,
      relativePoints: [{
        x: n.left ? 0 : 1,
        y: n.top ? 0 : 1
      }],
      offset: i.offset || "self",
      origin: {
        x: 0,
        y: 0
      },
      range: i.range
    }
  }, t.targetFields = t.targetFields || [["width", "height"], ["x", "y"]], Oe.start(e), t.offsets = e.state.offsets, e.state = t;
}
function wo(e) {
  const {
    interaction: t,
    state: n,
    coords: i
  } = e, {
    options: o,
    offsets: s
  } = n, a = {
    x: i.x - s[0].x,
    y: i.y - s[0].y
  };
  n.options = I({}, o), n.options.targets = [];
  for (const c of o.targets || []) {
    let r;
    if (p.func(c) ? r = c(a.x, a.y, t) : r = c, !!r) {
      for (const [f, d] of n.targetFields)
        if (f in r || d in r) {
          r.x = r[f], r.y = r[d];
          break;
        }
      n.options.targets.push(r);
    }
  }
  const l = Oe.set(e);
  return n.options = o, l;
}
var So = {
  range: 1 / 0,
  targets: null,
  offset: null,
  endOnly: false,
  enabled: false
};
var ne = {
  start: xo,
  set: wo,
  defaults: So
};
var Eo = mt(ne, "snapSize");
function zo(e) {
  const {
    edges: t
  } = e;
  return t ? (e.state.targetFields = e.state.targetFields || [[t.left ? "left" : "right", t.top ? "top" : "bottom"]], ne.start(e)) : null;
}
var Io = {
  start: zo,
  set: ne.set,
  defaults: I(Rt(ne.defaults), {
    targets: void 0,
    range: void 0,
    offset: {
      x: 0,
      y: 0
    }
  })
};
var To = mt(Io, "snapEdges");
var Lt = () => {
};
Lt._defaults = {};
var me = {
  aspectRatio: Vr,
  restrictEdges: io,
  restrict: Qr,
  restrictRect: so,
  restrictSize: po,
  snapEdges: To,
  snap: bo,
  snapSize: Eo,
  spring: Lt,
  avoid: Lt,
  transform: Lt,
  rubberband: Lt
};
var Do = {
  id: "modifiers",
  install(e) {
    const {
      interactStatic: t
    } = e;
    e.usePlugin(Yr), e.usePlugin(Fr), t.modifiers = me;
    for (const n in me) {
      const {
        _defaults: i,
        _methods: o
      } = me[n];
      i._methods = o, e.defaults.perAction[n] = i;
    }
  }
};
ut.use(Do);
var Ft = function(e) {
  return e.touchAction = "touchAction", e.boxSizing = "boxSizing", e.noListeners = "noListeners", e;
}(Ft || {});
var Se = "[interact.js] ";
var Ee = {
  touchAction: "https://developer.mozilla.org/en-US/docs/Web/CSS/touch-action",
  boxSizing: "https://developer.mozilla.org/en-US/docs/Web/CSS/box-sizing"
};
function Mo(e) {
  let {
    logger: t
  } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
  const {
    Interactable: n,
    defaults: i
  } = e;
  e.logger = t || console, i.base.devTools = {
    ignore: {}
  }, n.prototype.devTools = function(s) {
    return s ? (I(this.options.devTools, s), this) : this.options.devTools;
  };
  const {
    _onOff: o
  } = n.prototype;
  n.prototype._onOff = function(s, a, l, c, r) {
    if (p.string(this.target) || this.target.addEventListener)
      return o.call(this, s, a, l, c, r);
    p.object(a) && !p.array(a) && (c = l, l = null);
    const f = Et(a, l, r);
    for (const d in f)
      qt(d, e.actions) || e.logger.warn(Se + `Can't add native "${d}" event listener to target without \`addEventListener(type, listener, options)\` prop.`);
    return o.call(this, s, f, c);
  };
}
var tn = [{
  name: Ft.touchAction,
  perform(e) {
    let {
      element: t
    } = e;
    return !!t && !Co(t, "touchAction", /pan-|pinch|none/);
  },
  getInfo(e) {
    let {
      element: t
    } = e;
    return [t, Ee.touchAction];
  },
  text: `Consider adding CSS "touch-action: none" to this element
`
}, {
  name: Ft.boxSizing,
  perform(e) {
    const {
      element: t
    } = e;
    return e.prepared.name === "resize" && t instanceof q.HTMLElement && !Yn(t, "boxSizing", /border-box/);
  },
  text: 'Consider adding CSS "box-sizing: border-box" to this resizable element',
  getInfo(e) {
    let {
      element: t
    } = e;
    return [t, Ee.boxSizing];
  }
}, {
  name: Ft.noListeners,
  perform(e) {
    var t;
    const n = e.prepared.name;
    return !(((t = e.interactable) == null ? void 0 : t.events.types[`${n}move`]) || []).length;
  },
  getInfo(e) {
    return [e.prepared.name, e.interactable];
  },
  text: "There are no listeners set for this action"
}];
function Yn(e, t, n) {
  const i = e.style[t] || pt.getComputedStyle(e)[t];
  return n.test((i || "").toString());
}
function Co(e, t, n) {
  let i = e;
  for (; p.element(i); ) {
    if (Yn(i, t, n))
      return true;
    i = gt(i);
  }
  return false;
}
var _o = "dev-tools";
var Po = {
  id: _o,
  install: Mo,
  listeners: {
    "interactions:action-start": (e, t) => {
      let {
        interaction: n
      } = e;
      for (const i of tn) {
        const o = n.interactable && n.interactable.options;
        !(o && o.devTools && o.devTools.ignore[i.name]) && i.perform(n) && t.logger.warn(Se + i.text, ...i.getInfo(n));
      }
    }
  },
  checks: tn,
  CheckName: Ft,
  links: Ee,
  prefix: Se
};
ut.use(Po);
function Oo(e) {
  let t = 0, n;
  for (let i = 0, o = e.length; i < o; i++)
    n = e[i].y + e[i].h, n > t && (t = n);
  return t;
}
function St(e) {
  return (e || []).map((t) => ({ ...t }));
}
function qn(e, t) {
  return !(e === t || e.x + e.w <= t.x || e.x >= t.x + t.w || e.y + e.h <= t.y || e.y >= t.y + t.h);
}
function Wt(e, t, n) {
  const i = Un(e), o = Vn(e), s = Array(e.length);
  for (let a = 0, l = o.length; a < l; a++) {
    let c = o[a];
    c.static || (c = Ro(i, c, t, n), i.push(c)), s[e.indexOf(c)] = c, delete c.moved;
  }
  return s;
}
function Ro(e, t, n, i) {
  if (n)
    for (; t.y > 0 && !jt(e, t); )
      t.y--;
  else if (i) {
    const s = i[t.i].y;
    for (; t.y > s && !jt(e, t); )
      t.y--;
  }
  let o;
  for (; o = jt(e, t); )
    t.y = o.y + o.h;
  return t;
}
function ko(e, t) {
  const n = Un(e);
  for (let i = 0, o = e.length; i < o; i++) {
    const s = e[i];
    if (s.x + s.w > t.cols && (s.x = t.cols - s.w), s.x < 0 && (s.x = 0, s.w = t.cols), !s.static)
      n.push(s);
    else
      for (; jt(n, s); )
        s.y++;
  }
  return e;
}
function en(e, t) {
  for (let n = 0, i = e.length; n < i; n++)
    if (e[n].i === t)
      return e[n];
}
function jt(e, t) {
  for (let n = 0, i = e.length; n < i; n++)
    if (qn(e[n], t))
      return e[n];
}
function Gn(e, t) {
  return e.filter((n) => qn(n, t));
}
function Un(e) {
  return e.filter((t) => t.static);
}
function ze(e, t, n, i, o, s) {
  if (t.static)
    return e;
  const a = t.x, l = t.y, c = i && t.y > i;
  typeof n == "number" && (t.x = n), typeof i == "number" && (t.y = i), t.moved = true;
  let r = Vn(e);
  c && (r = r.reverse());
  const f = Gn(r, t);
  if (s && f.length)
    return t.x = a, t.y = l, t.moved = false, e;
  for (let d = 0, m = f.length; d < m; d++) {
    const g = f[d];
    g.moved || t.y > g.y && t.y - g.y > g.h / 4 || (g.static ? e = nn(e, g, t, o) : e = nn(e, t, g, o));
  }
  return e;
}
function nn(e, t, n, i) {
  if (i) {
    const s = {
      x: n.x,
      y: n.y,
      w: n.w,
      h: n.h,
      i: "-1"
    };
    if (s.y = Math.max(t.y - n.h, 0), !jt(e, s))
      return ze(e, n, void 0, s.y, false);
  }
  return ze(e, n, void 0, n.y + 1, false);
}
function Ao(e, t, n, i) {
  const o = `translate3d(${t}px,${e}px, 0)`;
  return {
    transform: o,
    WebkitTransform: o,
    MozTransform: o,
    msTransform: o,
    OTransform: o,
    width: `${n}px`,
    height: `${i}px`,
    position: "absolute"
  };
}
function $o(e, t, n, i) {
  const o = `translate3d(${t * -1}px,${e}px, 0)`;
  return {
    transform: o,
    WebkitTransform: o,
    MozTransform: o,
    msTransform: o,
    OTransform: o,
    width: `${n}px`,
    height: `${i}px`,
    position: "absolute"
  };
}
function Ho(e, t, n, i) {
  return {
    top: `${e}px`,
    left: `${t}px`,
    width: `${n}px`,
    height: `${i}px`,
    position: "absolute"
  };
}
function Lo(e, t, n, i) {
  return {
    top: `${e}px`,
    right: `${t}px`,
    width: `${n}px`,
    height: `${i}px`,
    position: "absolute"
  };
}
function Vn(e) {
  return [].concat(e).sort((t, n) => t.y === n.y && t.x === n.x ? 0 : t.y > n.y || t.y === n.y && t.x > n.x ? 1 : -1);
}
function Wo(e, t) {
  t = t || "Layout";
  const n = ["x", "y", "w", "h"], i = [];
  if (!Array.isArray(e))
    throw new Error(`${t} must be an array!`);
  for (let o = 0, s = e.length; o < s; o++) {
    const a = e[o];
    for (let l = 0; l < n.length; l++)
      if (typeof a[n[l]] != "number")
        throw new Error(`VueGridLayout: ${t}[${o}].${n[l]} must be a number!`);
    if (a.i === void 0 || a.i === null)
      throw new Error(`VueGridLayout: ${t}[${o}].i cannot be null!`);
    if (typeof a.i != "number" && typeof a.i != "string")
      throw new Error(`VueGridLayout: ${t}[${o}].i must be a string or number!`);
    if (i.indexOf(a.i) >= 0)
      throw new Error(`VueGridLayout: ${t}[${o}].i must be unique!`);
    if (i.push(a.i), a.static !== void 0 && typeof a.static != "boolean")
      throw new Error(`VueGridLayout: ${t}[${o}].static must be a boolean!`);
  }
}
function rn(e) {
  return Bo(e);
}
function Bo(e) {
  const t = e.target.offsetParent || document.body, n = e.offsetParent === document.body ? { left: 0, top: 0 } : t.getBoundingClientRect(), i = e.clientX + t.scrollLeft - n.left, o = e.clientY + t.scrollTop - n.top;
  return { x: i, y: o };
}
function on(e, t, n, i) {
  return No(e) ? {
    deltaX: n - e,
    deltaY: i - t,
    lastX: e,
    lastY: t,
    x: n,
    y: i
  } : {
    deltaX: 0,
    deltaY: 0,
    lastX: n,
    lastY: i,
    x: n,
    y: i
  };
}
function No(e) {
  return typeof e == "number" && !Number.isNaN(e);
}
function Fo(e, t) {
  const n = Jn(e);
  let i = n[0];
  for (let o = 1, s = n.length; o < s; o++) {
    const a = n[o];
    t > e[a] && (i = a);
  }
  return i;
}
function Kn(e, t) {
  if (!t[e])
    throw new Error(`ResponsiveGridLayout: \`cols\` entry for breakpoint ${e} is missing!`);
  return t[e];
}
function jo(e, t, n, i, o, s) {
  if (t[i])
    return St(t[i]);
  let a = e;
  const l = Jn(n), c = l.slice(l.indexOf(i));
  for (let r = 0, f = c.length; r < f; r++) {
    const d = c[r];
    if (t[d]) {
      a = t[d];
      break;
    }
  }
  return a = St(a || []), Wt(ko(a, { cols: o }), s);
}
function Jn(e) {
  return Object.keys(e).sort((n, i) => e[n] - e[i]);
}
var Zn = (e, t) => {
  const n = e.__vccOpts || e;
  for (const [i, o] of t)
    n[i] = o;
  return n;
};
var Xo = ["id"];
var Yo = {
  __name: "grid-item",
  props: {
    i: {
      required: true
    },
    x: {
      type: Number,
      required: true
    },
    y: {
      type: Number,
      required: true
    },
    w: {
      type: Number,
      required: true
    },
    h: {
      type: Number,
      required: true
    },
    minW: {
      type: Number,
      required: false,
      default: 1
    },
    minH: {
      type: Number,
      required: false,
      default: 1
    },
    maxW: {
      type: Number,
      required: false,
      default: 1 / 0
    },
    maxH: {
      type: Number,
      required: false,
      default: 1 / 0
    },
    // cols: {
    //   type: Number,
    //   required: true
    // },
    // containerWidth: {
    //   type: Number,
    //   required: true
    // },
    // rowHeight: {
    //   type: Number,
    //   required: true
    // },
    // margin: {
    //   type: Array,
    //   required: true
    // },
    // maxRows: {
    //   type: Number,
    //   required: true
    // },
    isDraggable: {
      type: Boolean,
      required: false,
      default: null
    },
    isResizable: {
      type: Boolean,
      required: false,
      default: null
    },
    isBounded: {
      type: Boolean,
      required: false,
      default: null
    },
    // useCssTransforms: {
    //   type: Boolean,
    //   required: true
    // },
    static: {
      type: Boolean,
      required: false,
      default: false
    },
    dragIgnoreFrom: {
      type: String,
      required: false,
      default: "a, button"
    },
    dragAllowFrom: {
      type: String,
      required: false,
      default: null
    },
    resizeIgnoreFrom: {
      type: String,
      required: false,
      default: "a, button"
    },
    preserveAspectRatio: {
      type: Boolean,
      required: false,
      default: false
    },
    dragOption: {
      type: Object,
      required: false,
      default: () => ({})
    },
    resizeOption: {
      type: Object,
      required: false,
      default: () => ({})
    }
  },
  emits: [
    "container-resized",
    "resize",
    "resized",
    "move",
    "moved"
  ],
  setup(e, { expose: t, emit: n }) {
    const i = e, o = n, s = {
      el: void 0,
      calcXY: O
    };
    t(s);
    const a = inject("emitter"), l = inject("gridLayout");
    let c;
    const r = reactive({
      cols: 1,
      containerWidth: 100,
      rowHeight: 30,
      margin: [10, 10],
      maxRows: 1 / 0,
      draggable: null,
      resizable: null,
      bounded: null,
      transformScale: 1,
      useCssTransforms: true,
      useStyleCursor: true,
      isDragging: false,
      dragging: null,
      isResizing: false,
      resizing: null,
      lastX: NaN,
      lastY: NaN,
      lastW: NaN,
      lastH: NaN,
      style: {},
      dragEventSet: false,
      resizeEventSet: false,
      previousW: null,
      previousH: null,
      previousX: null,
      previousY: null,
      innerX: i.x,
      innerY: i.y,
      innerW: i.w,
      innerH: i.h
    }), f = computed(() => ({
      "vue-resizable": unref(d),
      static: i.static,
      resizing: r.isResizing,
      "vue-draggable-dragging": r.isDragging,
      cssTransforms: r.useCssTransforms,
      "render-rtl": unref(g),
      "disable-userselect": r.isDragging,
      // 'no-touch': unref(isAndroid) && unref(draggableOrResizableAndNotStatic),
      "no-touch": unref(m)
    })), d = computed(() => r.resizable && !i.static), m = computed(() => (r.draggable || r.resizable) && !i.static), g = computed(() => l.props.isMirrored), b = computed(() => unref(g) ? "vue-resizable-handle vue-rtl-resizable-handle" : "vue-resizable-handle");
    function C() {
      a.on("updateWidth", vt), a.on("setDraggable", k), a.on("setResizable", A), a.on("setBounded", S), a.on("setTransformScale", _), a.on("setRowHeight", v), a.on("setMaxRows", u), a.on("directionchange", w), a.on("setColNum", y);
    }
    C(), onBeforeUnmount(() => {
      a.off("updateWidth", vt), a.off("setDraggable", k), a.off("setResizable", A), a.off("setBounded", S), a.off("setTransformScale", _), a.off("setRowHeight", v), a.off("setMaxRows", u), a.off("directionchange", w), a.off("setColNum", y), c && c.unset();
    }), onMounted(() => {
      const h = { ...l.props, ...l.state };
      h.responsive && h.lastBreakpoint ? r.cols = Kn(h.lastBreakpoint, h.cols) : r.cols = h.colNum, r.rowHeight = h.rowHeight, r.containerWidth = h.width !== null ? h.width : 100, r.margin = h.margin !== void 0 ? h.margin : [10, 10], r.maxRows = h.maxRows, i.isDraggable === null ? r.draggable = h.isDraggable : r.draggable = i.isDraggable, i.isResizable === null ? r.resizable = h.isResizable : r.resizable = i.isResizable, i.isBounded === null ? r.bounded = h.isBounded : r.bounded = i.isBounded, r.transformScale = h.transformScale, r.useCssTransforms = h.useCssTransforms, r.useStyleCursor = h.useStyleCursor, T();
    }), watch(() => i.isDraggable, () => {
      r.draggable = i.isDraggable;
    }), watch(() => i.static, () => {
      yt(), tt();
    }), watch(() => r.draggable, () => {
      yt();
    }), watch(() => i.isResizable, () => {
      r.resizable = i.isResizable;
    }), watch(() => i.isBounded, () => {
      r.bounded = i.isBounded;
    }), watch(() => r.resizable, () => {
      tt();
    }), watch(() => r.rowHeight, () => {
      T(), j();
    }), watch(() => r.cols, () => {
      tt(), T(), j();
    }), watch(() => r.containerWidth, () => {
      tt(), T(), j();
    }), watch(() => i.x, (h) => {
      r.innerX = h, T();
    }), watch(() => i.y, (h) => {
      r.innerY = h, T();
    }), watch(() => i.h, (h) => {
      r.innerH = h, T();
    }), watch(() => i.w, (h) => {
      r.innerW = h, T();
    }), watch(g, () => {
      tt(), T();
    }), watch(() => i.minH, () => {
      tt();
    }), watch(() => i.maxH, () => {
      tt();
    }), watch(() => i.minW, () => {
      tt();
    }), watch(() => i.maxW, () => {
      tt();
    }), watch(() => l.props.margin, (h) => {
      !h || Number(h[0]) === Number(r.margin[0]) && Number(h[1]) === Number(r.margin[1]) || (r.margin = h.map((R) => Number(R) || 0), T(), j());
    });
    function k(h) {
      i.isDraggable === null && (r.draggable = h);
    }
    function A(h) {
      i.isResizable === null && (r.resizable = h);
    }
    function S(h) {
      i.isBounded === null && (r.bounded = h);
    }
    function _(h) {
      r.transformScale = h;
    }
    function v(h) {
      r.rowHeight = h;
    }
    function u(h) {
      r.maxRows = h;
    }
    function w() {
      T();
    }
    function y(h) {
      r.cols = parseInt(h);
    }
    function T() {
      i.x + i.w > r.cols ? (r.innerX = 0, r.innerW = i.w > r.cols ? r.cols : i.w) : (r.innerX = i.x, r.innerW = i.w);
      const h = D(r.innerX, r.innerY, r.innerW, r.innerH);
      r.isDragging && (h.top = r.dragging.top, unref(g) ? h.right = r.dragging.left : h.left = r.dragging.left), r.isResizing && (h.width = r.resizing.width, h.height = r.resizing.height);
      let R;
      r.useCssTransforms ? unref(g) ? R = $o(h.top, h.right, h.width, h.height) : R = Ao(h.top, h.left, h.width, h.height) : unref(g) ? R = Lo(h.top, h.right, h.width, h.height) : R = Ho(h.top, h.left, h.width, h.height), r.style = R;
    }
    function j() {
      const h = {};
      for (const R of ["width", "height"]) {
        const X = r.style[R].match(/^(\d+)px$/);
        if (!X)
          return;
        h[R] = X[1];
      }
      o("container-resized", i.i, i.h, i.w, h.height, h.width);
    }
    function H(h) {
      if (i.static)
        return;
      const R = rn(h);
      if (R == null)
        return;
      const { x: N, y: X } = R, E = { width: 0, height: 0 };
      let z;
      switch (h.type) {
        case "resizestart": {
          tt(), r.previousW = r.innerW, r.previousH = r.innerH, z = D(r.innerX, r.innerY, r.innerW, r.innerH), E.width = z.width, E.height = z.height, r.resizing = E, r.isResizing = true;
          break;
        }
        case "resizemove": {
          const U = on(r.lastW, r.lastH, N, X);
          unref(g) ? E.width = r.resizing.width - U.deltaX / r.transformScale : E.width = r.resizing.width + U.deltaX / r.transformScale, E.height = r.resizing.height + U.deltaY / r.transformScale, r.resizing = E;
          break;
        }
        case "resizeend": {
          z = D(r.innerX, r.innerY, r.innerW, r.innerH), E.width = z.width, E.height = z.height, r.resizing = null, r.isResizing = false;
          break;
        }
      }
      T(), z = Mt(E.height, E.width), z.w < i.minW && (z.w = i.minW), z.w > i.maxW && (z.w = i.maxW), z.h < i.minH && (z.h = i.minH), z.h > i.maxH && (z.h = i.maxH), z.h < 1 && (z.h = 1), z.w < 1 && (z.w = 1), r.lastW = N, r.lastH = X, (r.innerW !== z.w || r.innerH !== z.h) && o("resize", i.i, z.h, z.w, E.height, E.width), h.type === "resizeend" && (r.previousW !== r.innerW || r.previousH !== r.innerH) && o("resized", i.i, z.h, z.w, E.height, E.width), a.emit("resizeEvent", [
        h.type,
        i.i,
        r.innerX,
        r.innerY,
        z.h,
        z.w
      ]);
    }
    function P(h) {
      if (i.static || r.isResizing)
        return;
      const R = rn(h);
      if (R === null)
        return;
      const { x: N, y: X } = R, E = { top: 0, left: 0 };
      switch (h.type) {
        case "dragstart": {
          r.previousX = r.innerX, r.previousY = r.innerY;
          const U = h.target.offsetParent.getBoundingClientRect(), x = h.target.getBoundingClientRect(), $ = x.left / r.transformScale, B = U.left / r.transformScale, Z = x.right / r.transformScale, nt = U.right / r.transformScale, it = x.top / r.transformScale, rt = U.top / r.transformScale;
          unref(g) ? E.left = (Z - nt) * -1 : E.left = $ - B, E.top = it - rt, r.dragging = E, r.isDragging = true;
          break;
        }
        case "dragend": {
          if (!r.isDragging)
            return;
          const U = h.target.offsetParent.getBoundingClientRect(), x = h.target.getBoundingClientRect(), $ = x.left / r.transformScale, B = U.left / r.transformScale, Z = x.right / r.transformScale, nt = U.right / r.transformScale, it = x.top / r.transformScale, rt = U.top / r.transformScale;
          unref(g) ? E.left = (Z - nt) * -1 : E.left = $ - B, E.top = it - rt, r.dragging = null, r.isDragging = false;
          break;
        }
        case "dragmove": {
          const U = on(r.lastX, r.lastY, N, X);
          if (unref(g) ? E.left = r.dragging.left - U.deltaX / r.transformScale : E.left = r.dragging.left + U.deltaX / r.transformScale, E.top = r.dragging.top + U.deltaY / r.transformScale, r.bounded) {
            const x = h.target.offsetParent.clientHeight - Y(i.h, r.rowHeight, r.margin[1]);
            E.top = K(E.top, 0, x);
            const $ = L(), B = r.containerWidth - Y(i.w, $, r.margin[0]);
            E.left = K(E.left, 0, B);
          }
          r.dragging = E;
          break;
        }
      }
      T();
      let z;
      unref(g), z = O(E.top, E.left), r.lastX = N, r.lastY = X, (r.innerX !== z.x || r.innerY !== z.y) && o("move", i.i, z.x, z.y), h.type === "dragend" && (r.previousX !== r.innerX || r.previousY !== r.innerY) && o("moved", i.i, z.x, z.y), a.emit("dragEvent", [
        h.type,
        i.i,
        z.x,
        z.y,
        r.innerH,
        r.innerW
      ]);
    }
    function D(h, R, N, X) {
      const E = L();
      let z;
      return unref(g) ? z = {
        right: Math.round(E * h + (h + 1) * r.margin[0]),
        top: Math.round(r.rowHeight * R + (R + 1) * r.margin[1]),
        // 0 * Infinity === NaN, which causes problems with resize constriants;
        // Fix this if it occurs.
        // Note we do it here rather than later because Math.round(Infinity) causes deopt
        width: N === 1 / 0 ? N : Math.round(E * N + Math.max(0, N - 1) * r.margin[0]),
        height: X === 1 / 0 ? X : Math.round(r.rowHeight * X + Math.max(0, X - 1) * r.margin[1])
      } : z = {
        left: Math.round(E * h + (h + 1) * r.margin[0]),
        top: Math.round(r.rowHeight * R + (R + 1) * r.margin[1]),
        // 0 * Infinity === NaN, which causes problems with resize constriants;
        // Fix this if it occurs.
        // Note we do it here rather than later because Math.round(Infinity) causes deopt
        width: N === 1 / 0 ? N : Math.round(E * N + Math.max(0, N - 1) * r.margin[0]),
        height: X === 1 / 0 ? X : Math.round(r.rowHeight * X + Math.max(0, X - 1) * r.margin[1])
      }, z;
    }
    function O(h, R) {
      const N = L();
      let X = Math.round((R - r.margin[0]) / (N + r.margin[0])), E = Math.round((h - r.margin[1]) / (r.rowHeight + r.margin[1]));
      return X = Math.max(Math.min(X, r.cols - r.innerW), 0), E = Math.max(Math.min(E, r.maxRows - r.innerH), 0), { x: X, y: E };
    }
    function L() {
      return (r.containerWidth - r.margin[0] * (r.cols + 1)) / r.cols;
    }
    function Y(h, R, N) {
      return Number.isFinite(h) ? Math.round(
        R * h + Math.max(0, h - 1) * N
      ) : h;
    }
    function K(h, R, N) {
      return Math.max(Math.min(h, N), R);
    }
    function Mt(h, R, N = false) {
      const X = L();
      let E = Math.round((R + r.margin[0]) / (X + r.margin[0])), z = 0;
      return N ? z = Math.ceil((h + r.margin[1]) / (r.rowHeight + r.margin[1])) : z = Math.round((h + r.margin[1]) / (r.rowHeight + r.margin[1])), E = Math.max(Math.min(E, r.cols - r.innerX), 0), z = Math.max(Math.min(z, r.maxRows - r.innerY), 0), { w: E, h: z };
    }
    function vt(h, R) {
      r.containerWidth = h, R != null && (r.cols = R);
    }
    function yt() {
      if (c == null && (c = ut(s.el), r.useStyleCursor || c.styleCursor(false)), r.draggable && !i.static) {
        const h = {
          ignoreFrom: i.dragIgnoreFrom,
          allowFrom: i.dragAllowFrom,
          ...i.dragOption
        };
        c.draggable(h), r.dragEventSet || (r.dragEventSet = true, c.on("dragstart dragmove dragend", (R) => {
          P(R);
        }));
      } else
        c.draggable({
          enabled: false
        });
    }
    function tt() {
      if (c == null && (c = ut(s.el), r.useStyleCursor || c.styleCursor(false)), r.resizable && !i.static) {
        const h = D(0, 0, i.maxW, i.maxH), R = D(0, 0, i.minW, i.minH), N = {
          // allowFrom: "." + unref(resizableHandleClass).trim().replace(" ", "."),
          edges: {
            left: false,
            right: `.${unref(b).trim().replace(" ", ".")}`,
            bottom: `.${unref(b).trim().replace(" ", ".")}`,
            top: false
          },
          ignoreFrom: i.resizeIgnoreFrom,
          restrictSize: {
            min: {
              height: R.height * r.transformScale,
              width: R.width * r.transformScale
            },
            max: {
              height: h.height * r.transformScale,
              width: h.width * r.transformScale
            }
          },
          ...i.resizeOption
        };
        i.preserveAspectRatio && (N.modifiers = [
          ut.modifiers.aspectRatio({
            ratio: "preserve"
          })
        ]), c.resizable(N), r.resizeEventSet || (r.resizeEventSet = true, c.on("resizestart resizemove resizeend", (X) => {
          H(X);
        }));
      } else
        c.resizable({
          enabled: false
        });
    }
    function ce(h) {
      s.el = h;
    }
    return (h, R) => (openBlock(), createElementBlock("div", {
      ref: ce,
      class: normalizeClass(["vue-grid-item", f.value]),
      style: normalizeStyle(r.style),
      id: e.i,
      key: e.i
    }, [
      renderSlot(h.$slots, "default", {
        class: normalizeClass({ rtl: g.value })
      }, void 0, true),
      d.value ? (openBlock(), createElementBlock("span", {
        key: 0,
        class: normalizeClass(b.value)
      }, null, 2)) : createCommentVNode("", true)
    ], 14, Xo));
  }
};
var Qn = Zn(Yo, [["__scopeId", "data-v-99aff433"]]);
function qo(e) {
  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
}
var ti = { exports: {} };
var Go = ti.exports = {};
Go.forEach = function(e, t) {
  for (var n = 0; n < e.length; n++) {
    var i = t(e[n]);
    if (i)
      return i;
  }
};
var ei = ti.exports;
var Uo = function(e) {
  var t = e.stateHandler.getState;
  function n(a) {
    var l = t(a);
    return l && !!l.isDetectable;
  }
  function i(a) {
    t(a).isDetectable = true;
  }
  function o(a) {
    return !!t(a).busy;
  }
  function s(a, l) {
    t(a).busy = !!l;
  }
  return {
    isDetectable: n,
    markAsDetectable: i,
    isBusy: o,
    markBusy: s
  };
};
var Vo = function(e) {
  var t = {};
  function n(a) {
    var l = e.get(a);
    return l === void 0 ? [] : t[l] || [];
  }
  function i(a, l) {
    var c = e.get(a);
    t[c] || (t[c] = []), t[c].push(l);
  }
  function o(a, l) {
    for (var c = n(a), r = 0, f = c.length; r < f; ++r)
      if (c[r] === l) {
        c.splice(r, 1);
        break;
      }
  }
  function s(a) {
    var l = n(a);
    l && (l.length = 0);
  }
  return {
    get: n,
    add: i,
    removeListener: o,
    removeAllListeners: s
  };
};
var Ko = function() {
  var e = 1;
  function t() {
    return e++;
  }
  return {
    generate: t
  };
};
var Jo = function(e) {
  var t = e.idGenerator, n = e.stateHandler.getState;
  function i(s) {
    var a = n(s);
    return a && a.id !== void 0 ? a.id : null;
  }
  function o(s) {
    var a = n(s);
    if (!a)
      throw new Error("setId required the element to have a resize detection state.");
    var l = t.generate();
    return a.id = l, l;
  }
  return {
    get: i,
    set: o
  };
};
var Zo = function(e) {
  function t() {
  }
  var n = {
    log: t,
    warn: t,
    error: t
  };
  if (!e && window.console) {
    var i = function(o, s) {
      o[s] = function() {
        var l = console[s];
        if (l.apply)
          l.apply(console, arguments);
        else
          for (var c = 0; c < arguments.length; c++)
            l(arguments[c]);
      };
    };
    i(n, "log"), i(n, "warn"), i(n, "error");
  }
  return n;
};
var ni = { exports: {} };
var ii = ni.exports = {};
ii.isIE = function(e) {
  function t() {
    var i = navigator.userAgent.toLowerCase();
    return i.indexOf("msie") !== -1 || i.indexOf("trident") !== -1 || i.indexOf(" edge/") !== -1;
  }
  if (!t())
    return false;
  if (!e)
    return true;
  var n = function() {
    var i, o = 3, s = document.createElement("div"), a = s.getElementsByTagName("i");
    do
      s.innerHTML = "<!--[if gt IE " + ++o + "]><i></i><![endif]-->";
    while (a[0]);
    return o > 4 ? o : i;
  }();
  return e === n;
};
ii.isLegacyOpera = function() {
  return !!window.opera;
};
var ri = ni.exports;
var oi = { exports: {} };
var Qo = oi.exports = {};
Qo.getOption = ts;
function ts(e, t, n) {
  var i = e[t];
  return i == null && n !== void 0 ? n : i;
}
var es = oi.exports;
var sn = es;
var ns = function(t) {
  t = t || {};
  var n = t.reporter, i = sn.getOption(t, "async", true), o = sn.getOption(t, "auto", true);
  o && !i && (n && n.warn("Invalid options combination. auto=true and async=false is invalid. Setting async=true."), i = true);
  var s = an(), a, l = false;
  function c(b, C) {
    !l && o && i && s.size() === 0 && d(), s.add(b, C);
  }
  function r() {
    for (l = true; s.size(); ) {
      var b = s;
      s = an(), b.process();
    }
    l = false;
  }
  function f(b) {
    l || (b === void 0 && (b = i), a && (m(a), a = null), b ? d() : r());
  }
  function d() {
    a = g(r);
  }
  function m(b) {
    var C = clearTimeout;
    return C(b);
  }
  function g(b) {
    var C = function(k) {
      return setTimeout(k, 0);
    };
    return C(b);
  }
  return {
    add: c,
    force: f
  };
};
function an() {
  var e = {}, t = 0, n = 0, i = 0;
  function o(l, c) {
    c || (c = l, l = 0), l > n ? n = l : l < i && (i = l), e[l] || (e[l] = []), e[l].push(c), t++;
  }
  function s() {
    for (var l = i; l <= n; l++)
      for (var c = e[l], r = 0; r < c.length; r++) {
        var f = c[r];
        f();
      }
  }
  function a() {
    return t;
  }
  return {
    add: o,
    process: s,
    size: a
  };
}
var Re = "_erd";
function is(e) {
  return e[Re] = {}, si(e);
}
function si(e) {
  return e[Re];
}
function rs(e) {
  delete e[Re];
}
var os = {
  initState: is,
  getState: si,
  cleanState: rs
};
var Ht = ri;
var ss = function(e) {
  e = e || {};
  var t = e.reporter, n = e.batchProcessor, i = e.stateHandler.getState;
  if (!t)
    throw new Error("Missing required dependency: reporter.");
  function o(r, f) {
    function d() {
      f(r);
    }
    if (Ht.isIE(8))
      i(r).object = {
        proxy: d
      }, r.attachEvent("onresize", d);
    else {
      var m = l(r);
      if (!m)
        throw new Error("Element is not detectable by this strategy.");
      m.contentDocument.defaultView.addEventListener("resize", d);
    }
  }
  function s(r) {
    var f = e.important ? " !important; " : "; ";
    return (r.join(f) + f).trim();
  }
  function a(r, f, d) {
    d || (d = f, f = r, r = null), r = r || {}, r.debug;
    function m(g, b) {
      var C = s(["display: block", "position: absolute", "top: 0", "left: 0", "width: 100%", "height: 100%", "border: none", "padding: 0", "margin: 0", "opacity: 0", "z-index: -1000", "pointer-events: none"]), k = false, A = window.getComputedStyle(g), S = g.offsetWidth, _ = g.offsetHeight;
      i(g).startSize = {
        width: S,
        height: _
      };
      function v() {
        function u() {
          if (A.position === "static") {
            g.style.setProperty("position", "relative", r.important ? "important" : "");
            var T = function(j, H, P, D) {
              function O(Y) {
                return Y.replace(/[^-\d\.]/g, "");
              }
              var L = P[D];
              L !== "auto" && O(L) !== "0" && (j.warn("An element that is positioned static has style." + D + "=" + L + " which is ignored due to the static positioning. The element will need to be positioned relative, so the style." + D + " will be set to 0. Element: ", H), H.style.setProperty(D, "0", r.important ? "important" : ""));
            };
            T(t, g, A, "top"), T(t, g, A, "right"), T(t, g, A, "bottom"), T(t, g, A, "left");
          }
        }
        function w() {
          k || u();
          function T(H, P) {
            if (!H.contentDocument) {
              var D = i(H);
              D.checkForObjectDocumentTimeoutId && window.clearTimeout(D.checkForObjectDocumentTimeoutId), D.checkForObjectDocumentTimeoutId = setTimeout(function() {
                D.checkForObjectDocumentTimeoutId = 0, T(H, P);
              }, 100);
              return;
            }
            P(H.contentDocument);
          }
          var j = this;
          T(j, function(P) {
            b(g);
          });
        }
        A.position !== "" && (u(), k = true);
        var y = document.createElement("object");
        y.style.cssText = C, y.tabIndex = -1, y.type = "text/html", y.setAttribute("aria-hidden", "true"), y.onload = w, Ht.isIE() || (y.data = "about:blank"), i(g) && (g.appendChild(y), i(g).object = y, Ht.isIE() && (y.data = "about:blank"));
      }
      n ? n.add(v) : v();
    }
    Ht.isIE(8) ? d(f) : m(f, d);
  }
  function l(r) {
    return i(r).object;
  }
  function c(r) {
    if (i(r)) {
      var f = l(r);
      f && (Ht.isIE(8) ? r.detachEvent("onresize", f.proxy) : r.removeChild(f), i(r).checkForObjectDocumentTimeoutId && window.clearTimeout(i(r).checkForObjectDocumentTimeoutId), delete i(r).object);
    }
  }
  return {
    makeDetectable: a,
    addListener: o,
    uninstall: c
  };
};
var as = ei.forEach;
var cs = function(e) {
  e = e || {};
  var t = e.reporter, n = e.batchProcessor, i = e.stateHandler.getState;
  e.stateHandler.hasState;
  var o = e.idHandler;
  if (!n)
    throw new Error("Missing required dependency: batchProcessor");
  if (!t)
    throw new Error("Missing required dependency: reporter.");
  var s = f(), a = "erd_scroll_detection_scrollbar_style", l = "erd_scroll_detection_container";
  function c(v) {
    d(v, a, l);
  }
  c(window.document);
  function r(v) {
    var u = e.important ? " !important; " : "; ";
    return (v.join(u) + u).trim();
  }
  function f() {
    var v = 500, u = 500, w = document.createElement("div");
    w.style.cssText = r(["position: absolute", "width: " + v * 2 + "px", "height: " + u * 2 + "px", "visibility: hidden", "margin: 0", "padding: 0"]);
    var y = document.createElement("div");
    y.style.cssText = r(["position: absolute", "width: " + v + "px", "height: " + u + "px", "overflow: scroll", "visibility: none", "top: " + -v * 3 + "px", "left: " + -u * 3 + "px", "visibility: hidden", "margin: 0", "padding: 0"]), y.appendChild(w), document.body.insertBefore(y, document.body.firstChild);
    var T = v - y.clientWidth, j = u - y.clientHeight;
    return document.body.removeChild(y), {
      width: T,
      height: j
    };
  }
  function d(v, u, w) {
    function y(P, D) {
      D = D || function(L) {
        v.head.appendChild(L);
      };
      var O = v.createElement("style");
      return O.innerHTML = P, O.id = u, D(O), O;
    }
    if (!v.getElementById(u)) {
      var T = w + "_animation", j = w + "_animation_active", H = `/* Created by the element-resize-detector library. */
`;
      H += "." + w + " > div::-webkit-scrollbar { " + r(["display: none"]) + ` }

`, H += "." + j + " { " + r(["-webkit-animation-duration: 0.1s", "animation-duration: 0.1s", "-webkit-animation-name: " + T, "animation-name: " + T]) + ` }
`, H += "@-webkit-keyframes " + T + ` { 0% { opacity: 1; } 50% { opacity: 0; } 100% { opacity: 1; } }
`, H += "@keyframes " + T + " { 0% { opacity: 1; } 50% { opacity: 0; } 100% { opacity: 1; } }", y(H);
    }
  }
  function m(v) {
    v.className += " " + l + "_animation_active";
  }
  function g(v, u, w) {
    if (v.addEventListener)
      v.addEventListener(u, w);
    else if (v.attachEvent)
      v.attachEvent("on" + u, w);
    else
      return t.error("[scroll] Don't know how to add event listeners.");
  }
  function b(v, u, w) {
    if (v.removeEventListener)
      v.removeEventListener(u, w);
    else if (v.detachEvent)
      v.detachEvent("on" + u, w);
    else
      return t.error("[scroll] Don't know how to remove event listeners.");
  }
  function C(v) {
    return i(v).container.childNodes[0].childNodes[0].childNodes[0];
  }
  function k(v) {
    return i(v).container.childNodes[0].childNodes[0].childNodes[1];
  }
  function A(v, u) {
    var w = i(v).listeners;
    if (!w.push)
      throw new Error("Cannot add listener to an element that is not detectable.");
    i(v).listeners.push(u);
  }
  function S(v, u, w) {
    w || (w = u, u = v, v = null), v = v || {};
    function y() {
      if (v.debug) {
        var x = Array.prototype.slice.call(arguments);
        if (x.unshift(o.get(u), "Scroll: "), t.log.apply)
          t.log.apply(null, x);
        else
          for (var $ = 0; $ < x.length; $++)
            t.log(x[$]);
      }
    }
    function T(x) {
      function $(B) {
        var Z = B.getRootNode && B.getRootNode().contains(B);
        return B === B.ownerDocument.body || B.ownerDocument.body.contains(B) || Z;
      }
      return !$(x) || window.getComputedStyle(x) === null;
    }
    function j(x) {
      var $ = i(x).container.childNodes[0], B = window.getComputedStyle($);
      return !B.width || B.width.indexOf("px") === -1;
    }
    function H() {
      var x = window.getComputedStyle(u), $ = {};
      return $.position = x.position, $.width = u.offsetWidth, $.height = u.offsetHeight, $.top = x.top, $.right = x.right, $.bottom = x.bottom, $.left = x.left, $.widthCSS = x.width, $.heightCSS = x.height, $;
    }
    function P() {
      var x = H();
      i(u).startSize = {
        width: x.width,
        height: x.height
      }, y("Element start size", i(u).startSize);
    }
    function D() {
      i(u).listeners = [];
    }
    function O() {
      if (y("storeStyle invoked."), !i(u)) {
        y("Aborting because element has been uninstalled");
        return;
      }
      var x = H();
      i(u).style = x;
    }
    function L(x, $, B) {
      i(x).lastWidth = $, i(x).lastHeight = B;
    }
    function Y(x) {
      return C(x).childNodes[0];
    }
    function K() {
      return 2 * s.width + 1;
    }
    function Mt() {
      return 2 * s.height + 1;
    }
    function vt(x) {
      return x + 10 + K();
    }
    function yt(x) {
      return x + 10 + Mt();
    }
    function tt(x) {
      return x * 2 + K();
    }
    function ce(x) {
      return x * 2 + Mt();
    }
    function h(x, $, B) {
      var Z = C(x), nt = k(x), it = vt($), rt = yt(B), Q = tt($), F = ce(B);
      Z.scrollLeft = it, Z.scrollTop = rt, nt.scrollLeft = Q, nt.scrollTop = F;
    }
    function R() {
      var x = i(u).container;
      if (!x) {
        x = document.createElement("div"), x.className = l, x.style.cssText = r(["visibility: hidden", "display: inline", "width: 0px", "height: 0px", "z-index: -1", "overflow: hidden", "margin: 0", "padding: 0"]), i(u).container = x, m(x), u.appendChild(x);
        var $ = function() {
          i(u).onRendered && i(u).onRendered();
        };
        g(x, "animationstart", $), i(u).onAnimationStart = $;
      }
      return x;
    }
    function N() {
      function x() {
        var V = i(u).style;
        if (V.position === "static") {
          u.style.setProperty("position", "relative", v.important ? "important" : "");
          var at = function(_t, xt, li, Ut) {
            function ui(fi) {
              return fi.replace(/[^-\d\.]/g, "");
            }
            var le = li[Ut];
            le !== "auto" && ui(le) !== "0" && (_t.warn("An element that is positioned static has style." + Ut + "=" + le + " which is ignored due to the static positioning. The element will need to be positioned relative, so the style." + Ut + " will be set to 0. Element: ", xt), xt.style[Ut] = 0);
          };
          at(t, u, V, "top"), at(t, u, V, "right"), at(t, u, V, "bottom"), at(t, u, V, "left");
        }
      }
      function $(V, at, _t, xt) {
        return V = V ? V + "px" : "0", at = at ? at + "px" : "0", _t = _t ? _t + "px" : "0", xt = xt ? xt + "px" : "0", ["left: " + V, "top: " + at, "right: " + xt, "bottom: " + _t];
      }
      if (y("Injecting elements"), !i(u)) {
        y("Aborting because element has been uninstalled");
        return;
      }
      x();
      var B = i(u).container;
      B || (B = R());
      var Z = s.width, nt = s.height, it = r(["position: absolute", "flex: none", "overflow: hidden", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%", "left: 0px", "top: 0px"]), rt = r(["position: absolute", "flex: none", "overflow: hidden", "z-index: -1", "visibility: hidden"].concat($(-(1 + Z), -(1 + nt), -nt, -Z))), Q = r(["position: absolute", "flex: none", "overflow: scroll", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%"]), F = r(["position: absolute", "flex: none", "overflow: scroll", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%"]), et = r(["position: absolute", "left: 0", "top: 0"]), bt = r(["position: absolute", "width: 200%", "height: 200%"]), ot = document.createElement("div"), st = document.createElement("div"), Ct = document.createElement("div"), ke = document.createElement("div"), Gt = document.createElement("div"), Ae = document.createElement("div");
      ot.dir = "ltr", ot.style.cssText = it, ot.className = l, st.className = l, st.style.cssText = rt, Ct.style.cssText = Q, ke.style.cssText = et, Gt.style.cssText = F, Ae.style.cssText = bt, Ct.appendChild(ke), Gt.appendChild(Ae), st.appendChild(Ct), st.appendChild(Gt), ot.appendChild(st), B.appendChild(ot);
      function $e() {
        var V = i(u);
        V && V.onExpand ? V.onExpand() : y("Aborting expand scroll handler: element has been uninstalled");
      }
      function He() {
        var V = i(u);
        V && V.onShrink ? V.onShrink() : y("Aborting shrink scroll handler: element has been uninstalled");
      }
      g(Ct, "scroll", $e), g(Gt, "scroll", He), i(u).onExpandScroll = $e, i(u).onShrinkScroll = He;
    }
    function X() {
      function x(Q, F, et) {
        var bt = Y(Q), ot = vt(F), st = yt(et);
        bt.style.setProperty("width", ot + "px", v.important ? "important" : ""), bt.style.setProperty("height", st + "px", v.important ? "important" : "");
      }
      function $(Q) {
        var F = u.offsetWidth, et = u.offsetHeight, bt = F !== i(u).lastWidth || et !== i(u).lastHeight;
        y("Storing current size", F, et), L(u, F, et), n.add(0, function() {
          if (bt) {
            if (!i(u)) {
              y("Aborting because element has been uninstalled");
              return;
            }
            if (!B()) {
              y("Aborting because element container has not been initialized");
              return;
            }
            if (v.debug) {
              var st = u.offsetWidth, Ct = u.offsetHeight;
              (st !== F || Ct !== et) && t.warn(o.get(u), "Scroll: Size changed before updating detector elements.");
            }
            x(u, F, et);
          }
        }), n.add(1, function() {
          if (!i(u)) {
            y("Aborting because element has been uninstalled");
            return;
          }
          if (!B()) {
            y("Aborting because element container has not been initialized");
            return;
          }
          h(u, F, et);
        }), bt && Q && n.add(2, function() {
          if (!i(u)) {
            y("Aborting because element has been uninstalled");
            return;
          }
          if (!B()) {
            y("Aborting because element container has not been initialized");
            return;
          }
          Q();
        });
      }
      function B() {
        return !!i(u).container;
      }
      function Z() {
        function Q() {
          return i(u).lastNotifiedWidth === void 0;
        }
        y("notifyListenersIfNeeded invoked");
        var F = i(u);
        if (Q() && F.lastWidth === F.startSize.width && F.lastHeight === F.startSize.height)
          return y("Not notifying: Size is the same as the start size, and there has been no notification yet.");
        if (F.lastWidth === F.lastNotifiedWidth && F.lastHeight === F.lastNotifiedHeight)
          return y("Not notifying: Size already notified");
        y("Current size not notified, notifying..."), F.lastNotifiedWidth = F.lastWidth, F.lastNotifiedHeight = F.lastHeight, as(i(u).listeners, function(et) {
          et(u);
        });
      }
      function nt() {
        if (y("startanimation triggered."), j(u)) {
          y("Ignoring since element is still unrendered...");
          return;
        }
        y("Element rendered.");
        var Q = C(u), F = k(u);
        (Q.scrollLeft === 0 || Q.scrollTop === 0 || F.scrollLeft === 0 || F.scrollTop === 0) && (y("Scrollbars out of sync. Updating detector elements..."), $(Z));
      }
      function it() {
        if (y("Scroll detected."), j(u)) {
          y("Scroll event fired while unrendered. Ignoring...");
          return;
        }
        $(Z);
      }
      if (y("registerListenersAndPositionElements invoked."), !i(u)) {
        y("Aborting because element has been uninstalled");
        return;
      }
      i(u).onRendered = nt, i(u).onExpand = it, i(u).onShrink = it;
      var rt = i(u).style;
      x(u, rt.width, rt.height);
    }
    function E() {
      if (y("finalizeDomMutation invoked."), !i(u)) {
        y("Aborting because element has been uninstalled");
        return;
      }
      var x = i(u).style;
      L(u, x.width, x.height), h(u, x.width, x.height);
    }
    function z() {
      w(u);
    }
    function U() {
      y("Installing..."), D(), P(), n.add(0, O), n.add(1, N), n.add(2, X), n.add(3, E), n.add(4, z);
    }
    y("Making detectable..."), T(u) ? (y("Element is detached"), R(), y("Waiting until element is attached..."), i(u).onRendered = function() {
      y("Element is now attached"), U();
    }) : U();
  }
  function _(v) {
    var u = i(v);
    u && (u.onExpandScroll && b(C(v), "scroll", u.onExpandScroll), u.onShrinkScroll && b(k(v), "scroll", u.onShrinkScroll), u.onAnimationStart && b(u.container, "animationstart", u.onAnimationStart), u.container && v.removeChild(u.container));
  }
  return {
    makeDetectable: S,
    addListener: A,
    uninstall: _,
    initDocument: c
  };
};
var Bt = ei.forEach;
var ls = Uo;
var us = Vo;
var fs = Ko;
var ds = Jo;
var hs = Zo;
var cn = ri;
var ps = ns;
var ft = os;
var gs = ss;
var ms = cs;
function ln(e) {
  return Array.isArray(e) || e.length !== void 0;
}
function un(e) {
  if (Array.isArray(e))
    return e;
  var t = [];
  return Bt(e, function(n) {
    t.push(n);
  }), t;
}
function fn(e) {
  return e && e.nodeType === 1;
}
var vs = function(e) {
  e = e || {};
  var t;
  if (e.idHandler)
    t = {
      get: function(S) {
        return e.idHandler.get(S, true);
      },
      set: e.idHandler.set
    };
  else {
    var n = fs(), i = ds({
      idGenerator: n,
      stateHandler: ft
    });
    t = i;
  }
  var o = e.reporter;
  if (!o) {
    var s = o === false;
    o = hs(s);
  }
  var a = dt(e, "batchProcessor", ps({ reporter: o })), l = {};
  l.callOnAdd = !!dt(e, "callOnAdd", true), l.debug = !!dt(e, "debug", false);
  var c = us(t), r = ls({
    stateHandler: ft
  }), f, d = dt(e, "strategy", "object"), m = dt(e, "important", false), g = {
    reporter: o,
    batchProcessor: a,
    stateHandler: ft,
    idHandler: t,
    important: m
  };
  if (d === "scroll" && (cn.isLegacyOpera() ? (o.warn("Scroll strategy is not supported on legacy Opera. Changing to object strategy."), d = "object") : cn.isIE(9) && (o.warn("Scroll strategy is not supported on IE9. Changing to object strategy."), d = "object")), d === "scroll")
    f = ms(g);
  else if (d === "object")
    f = gs(g);
  else
    throw new Error("Invalid strategy name: " + d);
  var b = {};
  function C(S, _, v) {
    function u(P) {
      var D = c.get(P);
      Bt(D, function(L) {
        L(P);
      });
    }
    function w(P, D, O) {
      c.add(D, O), P && O(D);
    }
    if (v || (v = _, _ = S, S = {}), !_)
      throw new Error("At least one element required.");
    if (!v)
      throw new Error("Listener required.");
    if (fn(_))
      _ = [_];
    else if (ln(_))
      _ = un(_);
    else
      return o.error("Invalid arguments. Must be a DOM element or a collection of DOM elements.");
    var y = 0, T = dt(S, "callOnAdd", l.callOnAdd), j = dt(S, "onReady", function() {
    }), H = dt(S, "debug", l.debug);
    Bt(_, function(D) {
      ft.getState(D) || (ft.initState(D), t.set(D));
      var O = t.get(D);
      if (H && o.log("Attaching listener to element", O, D), !r.isDetectable(D)) {
        if (H && o.log(O, "Not detectable."), r.isBusy(D)) {
          H && o.log(O, "System busy making it detectable"), w(T, D, v), b[O] = b[O] || [], b[O].push(function() {
            y++, y === _.length && j();
          });
          return;
        }
        return H && o.log(O, "Making detectable..."), r.markBusy(D, true), f.makeDetectable({ debug: H, important: m }, D, function(Y) {
          if (H && o.log(O, "onElementDetectable"), ft.getState(Y)) {
            r.markAsDetectable(Y), r.markBusy(Y, false), f.addListener(Y, u), w(T, Y, v);
            var K = ft.getState(Y);
            if (K && K.startSize) {
              var Mt = Y.offsetWidth, vt = Y.offsetHeight;
              (K.startSize.width !== Mt || K.startSize.height !== vt) && u(Y);
            }
            b[O] && Bt(b[O], function(yt) {
              yt();
            });
          } else
            H && o.log(O, "Element uninstalled before being detectable.");
          delete b[O], y++, y === _.length && j();
        });
      }
      H && o.log(O, "Already detecable, adding listener."), w(T, D, v), y++;
    }), y === _.length && j();
  }
  function k(S) {
    if (!S)
      return o.error("At least one element is required.");
    if (fn(S))
      S = [S];
    else if (ln(S))
      S = un(S);
    else
      return o.error("Invalid arguments. Must be a DOM element or a collection of DOM elements.");
    Bt(S, function(_) {
      c.removeAllListeners(_), f.uninstall(_), ft.cleanState(_);
    });
  }
  function A(S) {
    f.initDocument && f.initDocument(S);
  }
  return {
    listenTo: C,
    removeListener: c.removeListener,
    removeAllListeners: c.removeAllListeners,
    uninstall: k,
    initDocument: A
  };
};
function dt(e, t, n) {
  var i = e[t];
  return i == null && n !== void 0 ? n : i;
}
var ys = qo(vs);
function bs(e) {
  return { all: e = e || /* @__PURE__ */ new Map(), on: function(t, n) {
    var i = e.get(t);
    i ? i.push(n) : e.set(t, [n]);
  }, off: function(t, n) {
    var i = e.get(t);
    i && (n ? i.splice(i.indexOf(n) >>> 0, 1) : e.set(t, []));
  }, emit: function(t, n) {
    var i = e.get(t);
    i && i.slice().map(function(o) {
      o(n);
    }), (i = e.get("*")) && i.slice().map(function(o) {
      o(t, n);
    });
  } };
}
function ai() {
  return typeof window < "u";
}
var ci = () => {
};
function xs(e, t = ci) {
  if (!ai) {
    t();
    return;
  }
  window.addEventListener(e, t);
}
function ws(e, t = ci) {
  ai && window.removeEventListener(e, t);
}
var Ss = {
  __name: "grid-layout",
  props: {
    layout: {
      type: Array,
      required: true
    },
    responsiveLayouts: {
      type: Object,
      default() {
        return {};
      }
    },
    colNum: {
      type: Number,
      default: 12
    },
    rowHeight: {
      type: Number,
      default: 150
    },
    maxRows: {
      type: Number,
      default: 1 / 0
    },
    margin: {
      type: Array,
      default() {
        return [10, 10];
      }
    },
    isDraggable: {
      type: Boolean,
      default: true
    },
    isResizable: {
      type: Boolean,
      default: true
    },
    isMirrored: {
      type: Boolean,
      default: false
    },
    isBounded: {
      type: Boolean,
      default: false
    },
    // If true, the container height swells and contracts to fit contents
    autoSize: {
      type: Boolean,
      default: true
    },
    verticalCompact: {
      type: Boolean,
      default: true
    },
    restoreOnDrag: {
      type: Boolean,
      default: false
    },
    preventCollision: {
      type: Boolean,
      default: false
    },
    useCssTransforms: {
      type: Boolean,
      default: true
    },
    responsive: {
      type: Boolean,
      default: false
    },
    breakpoints: {
      type: Object,
      default() {
        return { lg: 1200, md: 996, sm: 768, xs: 480, xxs: 0 };
      }
    },
    cols: {
      type: Object,
      default() {
        return { lg: 12, md: 10, sm: 6, xs: 4, xxs: 2 };
      }
    },
    useStyleCursor: {
      type: Boolean,
      default: true
    },
    transformScale: {
      type: Number,
      default: 1
    }
  },
  emits: [
    "update:layout",
    "layout-ready",
    "layout-created",
    "layout-before-mount",
    "layout-mounted",
    "layout-updated",
    "breakpoint-changed"
  ],
  setup(e, { expose: t, emit: n }) {
    const i = e, o = n, s = bs(), a = {
      el: void 0,
      placeholderEl: void 0,
      placeholder: {},
      emitter: s
    };
    t(a);
    const l = ys({
      strategy: "scroll",
      // <- For ultra performance.
      // See https://github.com/wnr/element-resize-detector/issues/110 about callOnAdd.
      callOnAdd: false
    }), c = reactive({
      width: null,
      mergedStyle: {},
      isDragging: false,
      placeholder: {
        x: 0,
        y: 0,
        w: 0,
        h: 0,
        i: -1
      },
      layout: [],
      layouts: {},
      // array to store all layouts from different breakpoints
      lastBreakpoint: null,
      // store last active breakpoint
      originalLayout: null
      // store original Layout
    });
    provide("emitter", s), provide("gridLayout", { props: i, state: c });
    function r() {
      s.on("resizeEvent", k), s.on("dragEvent", C), o("layout-created", i.layout), xs("resize", g);
    }
    r(), onBeforeMount(() => {
      o("layout-before-mount", c.layout);
    }), onMounted(() => {
      o("layout-mounted", c.layout);
    }), onBeforeUnmount(() => {
      s.off("resizeEvent", k), s.off("dragEvent", C), ws("resize", g), l && a.el && l.uninstall(a.el);
    }), watch(() => c.width, async (u, w) => {
      s.emit("updateWidth", c.width), m(), w === null && (await nextTick(), o("layout-ready", c.layout));
    }), watch(() => i.layout, () => {
      Wo(i.layout), c.originalLayout = i.layout, d();
    }, { deep: true, immediate: true }), watch(() => i.colNum, () => {
      c.colNum = i.colNum, s.emit("setColNum", i.colNum);
    }, { immediate: true }), watch(() => i.rowHeight, () => {
      s.emit("setRowHeight", i.rowHeight);
    }), watch(() => i.isDraggable, () => {
      s.emit("setDraggable", i.isDraggable);
    }), watch(() => i.isResizable, () => {
      s.emit("setResizable", i.isResizable);
    }), watch(() => i.isBounded, () => {
      s.emit("setBounded", i.isBounded);
    }), watch(() => i.transformScale, () => {
      s.emit("setTransformScale", i.transformScale);
    }), watch(() => i.responsive, () => {
      i.responsive || (c.layout = St(c.originalLayout), s.emit("setColNum", i.colNum)), g();
    }), watch(() => i.maxRows, () => {
      s.emit("setMaxRows", i.maxRows);
    }), watch(() => i.margin, () => {
      m();
    }, { deep: true });
    function f(u, w) {
      if ((u == null ? void 0 : u.length) !== (w == null ? void 0 : w.length))
        return true;
      let y = false, T = 0;
      for (; T < u.length; ) {
        const j = u[T], H = Object.keys(j), P = w[T], D = Object.keys(P), O = [.../* @__PURE__ */ new Set([...H, ...D])];
        let L = 0;
        for (; L < O.length; ) {
          const Y = O[L];
          if (j[Y] !== P[Y]) {
            y = true;
            break;
          }
          L += 1;
        }
        if (y)
          break;
        T += 1;
      }
      return y;
    }
    function d() {
      if (f(i.layout, c.layout) && (S(), c.layout = St(i.layout), Wt(c.layout, i.verticalCompact), s.emit("updateWidth", c.width), m(), f(i.layout, c.layout))) {
        const w = St(c.layout);
        o("layout-updated", w), o("update:layout", w);
      }
    }
    function m() {
      c.mergedStyle = {
        height: b()
      };
    }
    function g() {
      a.el && (c.width = a.el.offsetWidth), s.emit("resizeEvent");
    }
    function b() {
      var w;
      if (!i.autoSize)
        return;
      const u = ((w = i.margin) == null ? void 0 : w[1]) || 0;
      return `${Oo(c.layout) * (i.rowHeight + u) + u}px`;
    }
    function C([u, w, y, T, j, H] = []) {
      let P = en(c.layout, w);
      if (P == null && (P = { x: 0, y: 0 }), u === "dragstart" && !i.verticalCompact && (c.positionsBeforeDrag = c.layout.reduce((D, { i: O, x: L, y: Y }) => ({
        ...D,
        [O]: { x: L, y: Y }
      }), {})), u === "dragmove" || u === "dragstart" ? (c.placeholder.x = P.x, c.placeholder.y = P.y, c.placeholder.w = H, c.placeholder.h = j, c.isDragging = true) : c.isDragging = false, c.layout = ze(c.layout, P, y, T, true, i.preventCollision), i.restoreOnDrag ? (P.static = true, Wt(c.layout, i.verticalCompact, c.positionsBeforeDrag), P.static = false) : Wt(c.layout, i.verticalCompact), m(), u === "dragend" && delete c.positionsBeforeDrag, f(i.layout, c.layout)) {
        const D = St(c.layout);
        o("layout-updated", D), o("update:layout", D);
      }
    }
    function k([u, w, y, T, j, H] = []) {
      let P = en(c.layout, w);
      P == null && (P = { h: 0, w: 0 });
      let D;
      if (i.preventCollision) {
        const O = Gn(c.layout, { ...P, w: H, h: j }).filter(
          (L) => L.i !== P.i
        );
        if (D = O.length > 0, D) {
          let L = 1 / 0, Y = 1 / 0;
          O.forEach((K) => {
            K.x > P.x && (L = Math.min(L, K.x)), K.y > P.y && (Y = Math.min(Y, K.y));
          }), Number.isFinite(L) && (P.w = L - P.x), Number.isFinite(Y) && (P.h = Y - P.y);
        }
      }
      if (D || (P.w = H, P.h = j), u === "resizestart" || u === "resizemove" ? (c.placeholder.x = y, c.placeholder.y = T, c.placeholder.w = P.w, c.placeholder.h = P.h, c.isDragging = true) : c.isDragging = false, i.responsive && A(), Wt(c.layout, i.verticalCompact), m(), f(i.layout, c.layout)) {
        const O = St(c.layout);
        o("layout-updated", O), o("update:layout", O);
      }
    }
    function A() {
      const u = Fo(i.breakpoints, c.width), w = Kn(u, i.cols);
      w !== c.colNum && (c.colNum = w, c.layout = jo(
        c.layout,
        c.layouts,
        i.breakpoints,
        u,
        w,
        i.verticalCompact
      ), c.layouts[u] = c.layout, s.emit("setColNum", w)), c.lastBreakpoint !== u && (c.lastBreakpoint = u, o("breakpoint-changed", u, c.layout));
    }
    function S() {
      c.layouts = { ...i.responsiveLayouts };
    }
    function _(u) {
      !u || u === a.el || (a.el = u, l && l.listenTo(a.el, () => {
        g();
      }), c.width = a.el.offsetWidth);
    }
    function v(u) {
      u && (a.placeholder = u, a.placeholderEl = u.el);
    }
    return (u, w) => (openBlock(), createElementBlock("div", {
      ref: _,
      class: "vue-grid-layout",
      style: normalizeStyle(c.mergedStyle)
    }, [
      renderSlot(u.$slots, "default", {}, void 0, true),
      withDirectives(createVNode(Qn, {
        ref: v,
        class: "vue-grid-placeholder",
        x: c.placeholder.x,
        y: c.placeholder.y,
        w: c.placeholder.w,
        h: c.placeholder.h,
        i: "placeholder"
      }, null, 8, ["x", "y", "w", "h"]), [
        [vShow, c.isDragging]
      ])
    ], 4));
  }
};
var Es = Zn(Ss, [["__scopeId", "data-v-a10aee95"]]);
function dn(e) {
  dn.installed || (dn.installed = true, e.component("GridLayout", Es), e.component("GridItem", Qn));
}
export {
  Qn as GridItem,
  Es as GridLayout,
  dn as default,
  dn as install
};
//# sourceMappingURL=vue-grid-layout-v3.js.map