vue-grid-layout-v3
Version:
A draggable and resizable grid layout, as a Vue component.
5,259 lines • 157 kB
JavaScript
/**
* vue-grid-layout-v3 3.1.2
* coffeebi <merfais.bwq@163.com>
* https://github.com/merfais/vue-grid-layout-v3
*/
import { inject as Le, reactive as hn, computed as kt, unref as J, onBeforeUnmount as pn, onMounted as gn, watch as W, openBlock as ve, createElementBlock as ye, normalizeClass as ue, normalizeStyle as mn, renderSlot as vn, createCommentVNode as di, provide as We, onBeforeMount as hi, nextTick as pi, withDirectives as gi, createVNode as mi, vShow as vi } from "vue";
import './index.css';const 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;
let bn, 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;
}
const bi = (e) => e === pt || yn(e), xi = (e) => ie(e) && e.nodeType === 11, ie = (e) => !!e && typeof e == "object", wn = (e) => typeof e == "function", wi = (e) => typeof e == "number", Si = (e) => typeof e == "boolean", Ei = (e) => typeof e == "string", zi = (e) => {
if (!e || typeof e != "object")
return !1;
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";
}, Ii = (e) => ie(e) && !!e.constructor && /function Object\b/.test(e.constructor.toString()), 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
};
const 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 !== !1 && !!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";
}
const Sn = (e, t) => {
for (const n of t)
e.push(n);
return e;
}, En = (e) => Sn([], e), re = (e, t) => {
for (let n = 0; n < e.length; n++)
if (t(e[n], n, e))
return n;
return -1;
}, 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;
}
let Be = 0, ct, 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) => !0, 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);
}
}
class zn {
constructor(t) {
this.options = void 0, this.types = {}, this.propagationStopped = !1, this.immediatePropagationStopped = !1, 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 !0;
t = t.parentNode;
}
return !1;
}
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 !0;
if (e = gt(e), e === n)
return Tt(e, t);
}
return !1;
}
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), !0) : !1;
}
const _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: !0
});
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: !1,
supportsPassive: !1
};
(t = e.document) == null || t.createElement("div").addEventListener("test", null, {
get capture() {
return s.supportsOptions = !0;
},
get passive() {
return s.supportsPassive = !0;
}
}), 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 = !1;
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 = !0);
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, !0);
}
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 _ = !1, 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, !0)), _ = !0;
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, !0);
}
return s;
}
class Fi {
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: !1
};
}
function Vt(e, t) {
return e === t ? !0 : typeof e == "boolean" ? !!t.capture === e && !t.passive : !!e.capture == !!t.capture && !!e.passive == !!t.passive;
}
var ji = {
id: "events",
install: Ni
};
const 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 !== !1)
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 = !1;
return function() {
return n || (pt.console.warn(t), n = !0), 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
};
}
class On {
constructor(t) {
this.immediatePropagationStopped = !1, this.propagationStopped = !1, this._interaction = t;
}
preventDefault() {
}
/**
* Don't call any other listeners (even on the current target)
*/
stopPropagation() {
this.propagationStopped = !0;
}
/**
* Don't call listeners on the remaining targets
*/
stopImmediatePropagation() {
this.immediatePropagationStopped = this.propagationStopped = !0;
}
}
Object.defineProperty(On.prototype, "interaction", {
get() {
return this._interaction._proxy;
},
set() {
}
});
const Rn = {
base: {
preventDefault: "auto",
deltaSource: "page"
},
perAction: {
enabled: !1,
origin: {
x: 0,
y: 0
}
},
actions: {}
};
class _e 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 = !0;
}
/**
* Don't call any other listeners (even on the current target)
*/
stopPropagation() {
this.propagationStopped = !0;
}
}
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;
}
}
});
class Ki {
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;
}
}
let Ji = /* @__PURE__ */ function(e) {
return e.interactable = "", e.element = "", e.prepared = "", e.pointerIsDown = "", e.pointerWasMoved = "", e._proxy = "", e;
}({}), Zi = /* @__PURE__ */ function(e) {
return e.start = "", e.move = "", e.end = "", e.stop = "", e.interacting = "", e;
}({}), Qi = 0;
class tr {
/** @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 = !1, this.pointerWasMoved = !1, this._interacting = !1, this._ending = !1, this._stopped = !0, 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, !0), 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 ? !1 : (_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: !0,
right: !0,
top: !0,
bottom: !0
}, this._stopped = !1, 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, !1);
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, !1));
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 = !0, t = t || this._latestPointer.event;
let n;
this.interacting() && (n = this._doPhase({
event: t,
interaction: this,
phase: "end"
})), this._ending = !1, n === !0 && 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 = !1, this._stopped = !0, 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 === !1 ? !1 : 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 = !0, 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 = !1)), 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 = !1;
}
/** @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) === !1)
return !1;
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), !0;
}
/** @internal */
_now() {
return Date.now();
}
}
const 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;
});
}
const 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 = !1;
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: !1
});
for (const r in a.delegatedEvents)
l(n, r, a.delegateListener), l(n, r, a.delegateUseCapture, !0);
const c = o && o.events;
for (const {
type: r,
listener: f
} of s)
l(n, r, f, c);
}
const 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 !0;
for (const n in t.map)
if (e.indexOf(n) === 0 && e.substr(n.length) in t.phases)
return !0;
return !1;
}
var ht = /* @__PURE__ */ function(e) {
return e[e.On = 0] = "On", e[e.Off = 1] = "Off", e;
}(ht || {});
class ir {
/** @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 !== !1)) : 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) : !1 : !1 : !0;
}
/** @internal */
testIgnore(t, n, i) {
return !t || !p.element(i) ? !1 : p.string(t) ? be(i, t, n) : p.element(t) ? zt(t, i) : !1;
}
/**
* 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");
}
}
class rr {
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: !0
}), 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;
}
class sr {
constructor() {
this.id = `__interact_scope_${Math.floor(Math.random() * 100)}`, this.isInitialized = !1, this.listenerMaps = [], this.browser = G, this.defaults = Rt(Rn), this.Eventable = zn, this.actions = {
map: {},
phases: {
start: !0,
move: !0,
end: !0
},
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) === !1)
return !1;
}
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] = !0, a[Ue(l)] = !0, 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 !1;
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 = !0, 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(/\/.*$/, "");
}
const $n = new sr(), ut = $n.interactStatic, 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 = !0, I(n.perAction, {
manualStart: !1,
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 !1;
for (const d of i.interactions.list) {
const m = d.prepared.name;
if (d.interacting()) {
if (c++, c >= l)
return !1;
if (d.interactable === e && (r += m === n.name ? 1 : 0, r >= s || d.element === t && (f++, m === n.name && f >= a)))
return !1;
}
}
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);
}
const 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 !1;
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;
}
const 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 = !0, t.perAction.autoScroll = M.defaults;
}
const M = {
defaults: {
enabled: !1,
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: !1,
prevTime: 0,
margin: 0,
speed: 0,
start(e) {
M.isScrolling = !0, Ot.cancel(M.i), e.autoScroll = M, M.interaction = e, M.prevTime = M.now(), M.i = Ot.request(M.scroll);
},
stop() {
M.isScrolling = !1, 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
};
}
const 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;
}
}
const Cr = function(t) {
return p.object(t) ? (this.options.drag.enabled = t.enabled !== !1, 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;
}, 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
}, !1;
}
},
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: !1,
right: !1,
top: !1,
bottom: !1
};
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 ? !1 : void 0;
}
}
function Or(e, t, n) {
return p.object(t) ? (e.options.resize.enabled = t.enabled !== !1, 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 !1;
if (t === !0) {
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)
) : !1;
}
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));
}
const 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: !1,
preserveAspectRatio: !1,
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 = () => {
}, Wr = () => {
}, 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;
}, Nr = /* @__PURE__ */ Object.freeze({
__proto__: null,
edgeTarget: Lr,
elements: Wr,
grid: Br
});
const Fr = {
id: "snappers",
install(e) {
const {
interactStatic: t
} = e;
t.snappers = I(t.snappers || {}, Nr), t.createSnapGrid = t.snappers.grid;
}
};
class Fn {
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: !1,
right: !1,
top: !1,
bottom: !1
};
}
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: !1
});
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 !1;
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 = !1;
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, !1;
s = s || !s && this.shouldDo(l, !0, t.phase, !0);
}
s && n.move({
event: i,
preEnd: !0
});
}
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 === !1 || // 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: !0
};
}
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 !== !1;
for (const c in n)
c in a || (a[c] = n[c]);
const l = {
options: a,
methods: i,
name: t,
enable: () => (a.enabled = !0, l),
disable: () => (a.enabled = !1, 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);
}
const 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)
}
}, 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 !== !1 && 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: !1,
modifiers: [],
enabled: !1
}
};
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);
}
const Zr = {
restriction: null,
elementRect: null,
offset: null,
endOnly: !1,
enabled: !1
}, ee = {
start: Kr,
set: Jr,
defaults: Zr
};
var Qr = mt(ee, "restrict");
const jn = {
top: 1 / 0,
left: 1 / 0,
bottom: -1 / 0,
right: -1 / 0
}, 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;
}
const no = {
inner: null,
outer: null,
offset: null,
endOnly: !1,
enabled: !1
}, Nt = {
noInner: jn,
noOuter: Xn,
start: to,
set: eo,
defaults: no
};
var io = mt(Nt, "restrictEdges");
const ro = I({
get elementRect() {
return {
top: 0,
left: 0,
bottom: 1,
right: 1
};
},
set elementRect(e) {
}
}, ee.defaults), oo = {
start: ee.start,
set: ee.set,
defaults: ro
};
var so = mt(oo, "restrictRect");
const ao = {
width: -1 / 0,
height: -1 / 0
}, 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;
}
const fo = {
min: null,
max: null,
endOnly: !1,
enabled: !1
}, 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: !1,
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 = !1), (!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);
}
const yo = {
range: 1 / 0,
targets: null,
offset: null,
offsetWithOrigin: !0,
origin: null,
relativePoints: null,
endOnly: !1,
enabled: !1
}, 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;
}
const So = {
range: 1 / 0,
targets: null,
offset: null,
endOnly: !1,
enabled: !1
}, 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;
}
const 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");
const 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
};
const 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 = /* @__PURE__ */ function(e) {
return e.touchAction = "touchAction", e.boxSizing = "boxSizing", e.noListeners = "noListeners", e;
}(Ft || {});
const Se = "[interact.js] ", 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);
};
}
const 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 !0;
i = gt(i);
}
return !1;
}
const _o = "dev-tools", 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 = !0;
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 = !1, 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, !1);
}
return ze(e, n, void 0, n.y + 1, !1);
}
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]);
}
const Zn = (e, t) => {
const n = e.__vccOpts || e;
for (const [i, o] of t)
n[i] = o;
return n;
}, Xo = ["id"], Yo = {
__name: "grid-item",
props: {
i: {
required: !0
},
x: {
type: Number,
required: !0
},
y: {
type: Number,
required: !0
},
w: {
type: Number,
required: !0
},
h: {
type: Number,
required: !0
},
minW: {
type: Number,
required: !1,
default: 1
},
minH: {
type: Number,
required: !1,
default: 1
},
maxW: {
type: Number,
required: !1,
default: 1 / 0
},
maxH: {
type: Number,
required: !1,
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: !1,
default: null
},
isResizable: {
type: Boolean,
required: !1,
default: null
},
isBounded: {
type: Boolean,
required: !1,
default: null
},
// useCssTransforms: {
// type: Boolean,
// required: true
// },
static: {
type: Boolean,
required: !1,
default: !1
},
dragIgnoreFrom: {
type: String,
required: !1,
default: "a, button"
},
dragAllowFrom: {
type: String,
required: !1,
default: null
},
resizeIgnoreFrom: {
type: String,
required: !1,
default: "a, button"
},
preserveAspectRatio: {
type: Boolean,
required: !1,
default: !1
},
dragOption: {
type: Object,
required: !1,
default: () => ({})
},
resizeOption: {
type: Object,
required: !1,
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 = Le("emitter"), l = Le("gridLayout");
let c;
const r = hn({
cols: 1,
containerWidth: 100,
rowHeight: 30,
margin: [10, 10],
maxRows: 1 / 0,
draggable: null,
resizable: null,
bounded: null,
transformScale: 1,
useCssTransforms: !0,
useStyleCursor: !0,
isDragging: !1,
dragging: null,
isResizing: !1,
resizing: null,
lastX: NaN,
lastY: NaN,
lastW: NaN,
lastH: NaN,
style: {},
dragEventSet: !1,
resizeEventSet: !1,
previousW: null,
previousH: null,
previousX: null,
previousY: null,
innerX: i.x,
innerY: i.y,
innerW: i.w,
innerH: i.h
}), f = kt(() => ({
"vue-resizable": J(d),
static: i.static,
resizing: r.isResizing,
"vue-draggable-dragging": r.isDragging,
cssTransforms: r.useCssTransforms,
"render-rtl": J(g),
"disable-userselect": r.isDragging,
// 'no-touch': unref(isAndroid) && unref(draggableOrResizableAndNotStatic),
"no-touch": J(m)
})), d = kt(() => r.resizable && !i.static), m = kt(() => (r.draggable || r.resizable) && !i.static), g = kt(() => l.props.isMirrored), b = kt(() => J(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(), pn(() => {
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();
}), gn(() => {
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();
}), W(() => i.isDraggable, () => {
r.draggable = i.isDraggable;
}), W(() => i.static, () => {
yt(), tt();
}), W(() => r.draggable, () => {
yt();
}), W(() => i.isResizable, () => {
r.resizable = i.isResizable;
}), W(() => i.isBounded, () => {
r.bounded = i.isBounded;
}), W(() => r.resizable, () => {
tt();
}), W(() => r.rowHeight, () => {
T(), j();
}), W(() => r.cols, () => {
tt(), T(), j();
}), W(() => r.containerWidth, () => {
tt(), T(), j();
}), W(() => i.x, (h) => {
r.innerX = h, T();
}), W(() => i.y, (h) => {
r.innerY = h, T();
}), W(() => i.h, (h) => {
r.innerH = h, T();
}), W(() => i.w, (h) => {
r.innerW = h, T();
}), W(g, () => {
tt(), T();
}), W(() => i.minH, () => {
tt();
}), W(() => i.maxH, () => {
tt();
}), W(() => i.minW, () => {
tt();
}), W(() => i.maxW, () => {
tt();
}), W(() => 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, J(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 ? J(g) ? R = $o(h.top, h.right, h.width, h.height) : R = Ao(h.top, h.left, h.width, h.height) : J(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 = !0;
break;
}
case "resizemove": {
const U = on(r.lastW, r.lastH, N, X);
J(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 = !1;
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;
J(g) ? E.left = (Z - nt) * -1 : E.left = $ - B, E.top = it - rt, r.dragging = E, r.isDragging = !0;
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;
J(g) ? E.left = (Z - nt) * -1 : E.left = $ - B, E.top = it - rt, r.dragging = null, r.isDragging = !1;
break;
}
case "dragmove": {
const U = on(r.lastX, r.lastY, N, X);
if (J(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;
J(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 J(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 = !1) {
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(!1)), r.draggable && !i.static) {
const h = {
ignoreFrom: i.dragIgnoreFrom,
allowFrom: i.dragAllowFrom,
...i.dragOption
};
c.draggable(h), r.dragEventSet || (r.dragEventSet = !0, c.on("dragstart dragmove dragend", (R) => {
P(R);
}));
} else
c.draggable({
enabled: !1
});
}
function tt() {
if (c == null && (c = ut(s.el), r.useStyleCursor || c.styleCursor(!1)), 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: !1,
right: `.${J(b).trim().replace(" ", ".")}`,
bottom: `.${J(b).trim().replace(" ", ".")}`,
top: !1
},
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 = !0, c.on("resizestart resizemove resizeend", (X) => {
H(X);
}));
} else
c.resizable({
enabled: !1
});
}
function ce(h) {
s.el = h;
}
return (h, R) => (ve(), ye("div", {
ref: ce,
class: ue(["vue-grid-item", f.value]),
style: mn(r.style),
id: e.i,
key: e.i
}, [
vn(h.$slots, "default", {
class: ue({ rtl: g.value })
}, void 0, !0),
d.value ? (ve(), ye("span", {
key: 0,
class: ue(b.value)
}, null, 2)) : di("", !0)
], 14, Xo));
}
}, Qn = /* @__PURE__ */ 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: {} }, 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, 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 = !0;
}
function o(a) {
return !!t(a).busy;
}
function s(a, l) {
t(a).busy = !!l;
}
return {
isDetectable: n,
markAsDetectable: i,
isBusy: o,
markBusy: s
};
}, 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
};
}, Ko = function() {
var e = 1;
function t() {
return e++;
}
return {
generate: t
};
}, 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
};
}, 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;
}, ni = { exports: {} }, 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 !1;
if (!e)
return !0;
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, oi = { exports: {} }, 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, sn = es, ns = function(t) {
t = t || {};
var n = t.reporter, i = sn.getOption(t, "async", !0), o = sn.getOption(t, "auto", !0);
o && !i && (n && n.warn("Invalid options combination. auto=true and async=false is invalid. Setting async=true."), i = !0);
var s = an(), a, l = !1;
function c(b, C) {
!l && o && i && s.size() === 0 && d(), s.add(b, C);
}
function r() {
for (l = !0; s.size(); ) {
var b = s;
s = an(), b.process();
}
l = !1;
}
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
}, Ht = ri, 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 = !1, 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 = !0);
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
};
}, as = ei.forEach, 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
};
}, Bt = ei.forEach, ls = Uo, us = Vo, fs = Ko, ds = Jo, hs = Zo, cn = ri, ps = ns, ft = os, gs = ss, 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, !0);
},
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 === !1;
o = hs(s);
}
var a = dt(e, "batchProcessor", ps({ reporter: o })), l = {};
l.callOnAdd = !!dt(e, "callOnAdd", !0), l.debug = !!dt(e, "debug", !1);
var c = us(t), r = ls({
stateHandler: ft
}), f, d = dt(e, "strategy", "object"), m = dt(e, "important", !1), 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, !0), f.makeDetectable({ debug: H, important: m }, D, function(Y) {
if (H && o.log(O, "onElementDetectable"), ft.getState(Y)) {
r.markAsDetectable(Y), r.markBusy(Y, !1), 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;
}
const ys = /* @__PURE__ */ 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";
}
const ci = () => {
};
function xs(e, t = ci) {
if (!ai) {
t();
return;
}
window.addEventListener(e, t);
}
function ws(e, t = ci) {
ai && window.removeEventListener(e, t);
}
const Ss = {
__name: "grid-layout",
props: {
layout: {
type: Array,
required: !0
},
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: !0
},
isResizable: {
type: Boolean,
default: !0
},
isMirrored: {
type: Boolean,
default: !1
},
isBounded: {
type: Boolean,
default: !1
},
// If true, the container height swells and contracts to fit contents
autoSize: {
type: Boolean,
default: !0
},
verticalCompact: {
type: Boolean,
default: !0
},
restoreOnDrag: {
type: Boolean,
default: !1
},
preventCollision: {
type: Boolean,
default: !1
},
useCssTransforms: {
type: Boolean,
default: !0
},
responsive: {
type: Boolean,
default: !1
},
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: !0
},
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: !1
}), c = hn({
width: null,
mergedStyle: {},
isDragging: !1,
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
});
We("emitter", s), We("gridLayout", { props: i, state: c });
function r() {
s.on("resizeEvent", k), s.on("dragEvent", C), o("layout-created", i.layout), xs("resize", g);
}
r(), hi(() => {
o("layout-before-mount", c.layout);
}), gn(() => {
o("layout-mounted", c.layout);
}), pn(() => {
s.off("resizeEvent", k), s.off("dragEvent", C), ws("resize", g), l && a.el && l.uninstall(a.el);
}), W(() => c.width, async (u, w) => {
s.emit("updateWidth", c.width), m(), w === null && (await pi(), o("layout-ready", c.layout));
}), W(() => i.layout, () => {
Wo(i.layout), c.originalLayout = i.layout, d();
}, { deep: !0, immediate: !0 }), W(() => i.colNum, () => {
c.colNum = i.colNum, s.emit("setColNum", i.colNum);
}, { immediate: !0 }), W(() => i.rowHeight, () => {
s.emit("setRowHeight", i.rowHeight);
}), W(() => i.isDraggable, () => {
s.emit("setDraggable", i.isDraggable);
}), W(() => i.isResizable, () => {
s.emit("setResizable", i.isResizable);
}), W(() => i.isBounded, () => {
s.emit("setBounded", i.isBounded);
}), W(() => i.transformScale, () => {
s.emit("setTransformScale", i.transformScale);
}), W(() => i.responsive, () => {
i.responsive || (c.layout = St(c.originalLayout), s.emit("setColNum", i.colNum)), g();
}), W(() => i.maxRows, () => {
s.emit("setMaxRows", i.maxRows);
}), W(() => i.margin, () => {
m();
}, { deep: !0 });
function f(u, w) {
if ((u == null ? void 0 : u.length) !== (w == null ? void 0 : w.length))
return !0;
let y = !1, 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 = !0;
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 = !0) : c.isDragging = !1, c.layout = ze(c.layout, P, y, T, !0, i.preventCollision), i.restoreOnDrag ? (P.static = !0, Wt(c.layout, i.verticalCompact, c.positionsBeforeDrag), P.static = !1) : 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 = !0) : c.isDragging = !1, 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) => (ve(), ye("div", {
ref: _,
class: "vue-grid-layout",
style: mn(c.mergedStyle)
}, [
vn(u.$slots, "default", {}, void 0, !0),
gi(mi(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"]), [
[vi, c.isDragging]
])
], 4));
}
}, Es = /* @__PURE__ */ Zn(Ss, [["__scopeId", "data-v-a10aee95"]]);
function dn(e) {
dn.installed || (dn.installed = !0, e.component("GridLayout", Es), e.component("GridItem", Qn));
}
export {
Qn as GridItem,
Es as GridLayout,
dn as default,
dn as install
};