1397 lines
50 KiB
JavaScript
1397 lines
50 KiB
JavaScript
/**
|
|
* @popperjs/core v2.11.8 - MIT License
|
|
*/
|
|
|
|
!(function (e, t) {
|
|
"object" == typeof exports && "undefined" != typeof module
|
|
? t(exports)
|
|
: "function" == typeof define && define.amd
|
|
? define(["exports"], t)
|
|
: t(
|
|
((e =
|
|
"undefined" != typeof globalThis
|
|
? globalThis
|
|
: e || self).Popper = {})
|
|
);
|
|
})(this, function (e) {
|
|
"use strict";
|
|
function t(e) {
|
|
if (null == e) return window;
|
|
if ("[object Window]" !== e.toString()) {
|
|
var t = e.ownerDocument;
|
|
return (t && t.defaultView) || window;
|
|
}
|
|
return e;
|
|
}
|
|
function n(e) {
|
|
return e instanceof t(e).Element || e instanceof Element;
|
|
}
|
|
function r(e) {
|
|
return e instanceof t(e).HTMLElement || e instanceof HTMLElement;
|
|
}
|
|
function o(e) {
|
|
return (
|
|
"undefined" != typeof ShadowRoot &&
|
|
(e instanceof t(e).ShadowRoot || e instanceof ShadowRoot)
|
|
);
|
|
}
|
|
var i = Math.max,
|
|
a = Math.min,
|
|
s = Math.round;
|
|
function f() {
|
|
var e = navigator.userAgentData;
|
|
return null != e && e.brands && Array.isArray(e.brands)
|
|
? e.brands
|
|
.map(function (e) {
|
|
return e.brand + "/" + e.version;
|
|
})
|
|
.join(" ")
|
|
: navigator.userAgent;
|
|
}
|
|
function c() {
|
|
return !/^((?!chrome|android).)*safari/i.test(f());
|
|
}
|
|
function p(e, o, i) {
|
|
void 0 === o && (o = !1), void 0 === i && (i = !1);
|
|
var a = e.getBoundingClientRect(),
|
|
f = 1,
|
|
p = 1;
|
|
o &&
|
|
r(e) &&
|
|
((f = (e.offsetWidth > 0 && s(a.width) / e.offsetWidth) || 1),
|
|
(p = (e.offsetHeight > 0 && s(a.height) / e.offsetHeight) || 1));
|
|
var u = (n(e) ? t(e) : window).visualViewport,
|
|
l = !c() && i,
|
|
d = (a.left + (l && u ? u.offsetLeft : 0)) / f,
|
|
h = (a.top + (l && u ? u.offsetTop : 0)) / p,
|
|
m = a.width / f,
|
|
v = a.height / p;
|
|
return {
|
|
width: m,
|
|
height: v,
|
|
top: h,
|
|
right: d + m,
|
|
bottom: h + v,
|
|
left: d,
|
|
x: d,
|
|
y: h,
|
|
};
|
|
}
|
|
function u(e) {
|
|
var n = t(e);
|
|
return { scrollLeft: n.pageXOffset, scrollTop: n.pageYOffset };
|
|
}
|
|
function l(e) {
|
|
return e ? (e.nodeName || "").toLowerCase() : null;
|
|
}
|
|
function d(e) {
|
|
return (
|
|
(n(e) ? e.ownerDocument : e.document) || window.document
|
|
).documentElement;
|
|
}
|
|
function h(e) {
|
|
return p(d(e)).left + u(e).scrollLeft;
|
|
}
|
|
function m(e) {
|
|
return t(e).getComputedStyle(e);
|
|
}
|
|
function v(e) {
|
|
var t = m(e),
|
|
n = t.overflow,
|
|
r = t.overflowX,
|
|
o = t.overflowY;
|
|
return /auto|scroll|overlay|hidden/.test(n + o + r);
|
|
}
|
|
function y(e, n, o) {
|
|
void 0 === o && (o = !1);
|
|
var i,
|
|
a,
|
|
f = r(n),
|
|
c =
|
|
r(n) &&
|
|
(function (e) {
|
|
var t = e.getBoundingClientRect(),
|
|
n = s(t.width) / e.offsetWidth || 1,
|
|
r = s(t.height) / e.offsetHeight || 1;
|
|
return 1 !== n || 1 !== r;
|
|
})(n),
|
|
m = d(n),
|
|
y = p(e, c, o),
|
|
g = { scrollLeft: 0, scrollTop: 0 },
|
|
b = { x: 0, y: 0 };
|
|
return (
|
|
(f || (!f && !o)) &&
|
|
(("body" !== l(n) || v(m)) &&
|
|
(g =
|
|
(i = n) !== t(i) && r(i)
|
|
? {
|
|
scrollLeft: (a = i).scrollLeft,
|
|
scrollTop: a.scrollTop,
|
|
}
|
|
: u(i)),
|
|
r(n)
|
|
? (((b = p(n, !0)).x += n.clientLeft), (b.y += n.clientTop))
|
|
: m && (b.x = h(m))),
|
|
{
|
|
x: y.left + g.scrollLeft - b.x,
|
|
y: y.top + g.scrollTop - b.y,
|
|
width: y.width,
|
|
height: y.height,
|
|
}
|
|
);
|
|
}
|
|
function g(e) {
|
|
var t = p(e),
|
|
n = e.offsetWidth,
|
|
r = e.offsetHeight;
|
|
return (
|
|
Math.abs(t.width - n) <= 1 && (n = t.width),
|
|
Math.abs(t.height - r) <= 1 && (r = t.height),
|
|
{ x: e.offsetLeft, y: e.offsetTop, width: n, height: r }
|
|
);
|
|
}
|
|
function b(e) {
|
|
return "html" === l(e)
|
|
? e
|
|
: e.assignedSlot || e.parentNode || (o(e) ? e.host : null) || d(e);
|
|
}
|
|
function x(e) {
|
|
return ["html", "body", "#document"].indexOf(l(e)) >= 0
|
|
? e.ownerDocument.body
|
|
: r(e) && v(e)
|
|
? e
|
|
: x(b(e));
|
|
}
|
|
function w(e, n) {
|
|
var r;
|
|
void 0 === n && (n = []);
|
|
var o = x(e),
|
|
i = o === (null == (r = e.ownerDocument) ? void 0 : r.body),
|
|
a = t(o),
|
|
s = i ? [a].concat(a.visualViewport || [], v(o) ? o : []) : o,
|
|
f = n.concat(s);
|
|
return i ? f : f.concat(w(b(s)));
|
|
}
|
|
function O(e) {
|
|
return ["table", "td", "th"].indexOf(l(e)) >= 0;
|
|
}
|
|
function j(e) {
|
|
return r(e) && "fixed" !== m(e).position ? e.offsetParent : null;
|
|
}
|
|
function E(e) {
|
|
for (var n = t(e), i = j(e); i && O(i) && "static" === m(i).position; )
|
|
i = j(i);
|
|
return i &&
|
|
("html" === l(i) || ("body" === l(i) && "static" === m(i).position))
|
|
? n
|
|
: i ||
|
|
(function (e) {
|
|
var t = /firefox/i.test(f());
|
|
if (
|
|
/Trident/i.test(f()) &&
|
|
r(e) &&
|
|
"fixed" === m(e).position
|
|
)
|
|
return null;
|
|
var n = b(e);
|
|
for (
|
|
o(n) && (n = n.host);
|
|
r(n) && ["html", "body"].indexOf(l(n)) < 0;
|
|
|
|
) {
|
|
var i = m(n);
|
|
if (
|
|
"none" !== i.transform ||
|
|
"none" !== i.perspective ||
|
|
"paint" === i.contain ||
|
|
-1 !==
|
|
["transform", "perspective"].indexOf(
|
|
i.willChange
|
|
) ||
|
|
(t && "filter" === i.willChange) ||
|
|
(t && i.filter && "none" !== i.filter)
|
|
)
|
|
return n;
|
|
n = n.parentNode;
|
|
}
|
|
return null;
|
|
})(e) ||
|
|
n;
|
|
}
|
|
var D = "top",
|
|
A = "bottom",
|
|
L = "right",
|
|
P = "left",
|
|
M = "auto",
|
|
k = [D, A, L, P],
|
|
W = "start",
|
|
B = "end",
|
|
H = "viewport",
|
|
T = "popper",
|
|
R = k.reduce(function (e, t) {
|
|
return e.concat([t + "-" + W, t + "-" + B]);
|
|
}, []),
|
|
S = [].concat(k, [M]).reduce(function (e, t) {
|
|
return e.concat([t, t + "-" + W, t + "-" + B]);
|
|
}, []),
|
|
V = [
|
|
"beforeRead",
|
|
"read",
|
|
"afterRead",
|
|
"beforeMain",
|
|
"main",
|
|
"afterMain",
|
|
"beforeWrite",
|
|
"write",
|
|
"afterWrite",
|
|
];
|
|
function q(e) {
|
|
var t = new Map(),
|
|
n = new Set(),
|
|
r = [];
|
|
function o(e) {
|
|
n.add(e.name),
|
|
[]
|
|
.concat(e.requires || [], e.requiresIfExists || [])
|
|
.forEach(function (e) {
|
|
if (!n.has(e)) {
|
|
var r = t.get(e);
|
|
r && o(r);
|
|
}
|
|
}),
|
|
r.push(e);
|
|
}
|
|
return (
|
|
e.forEach(function (e) {
|
|
t.set(e.name, e);
|
|
}),
|
|
e.forEach(function (e) {
|
|
n.has(e.name) || o(e);
|
|
}),
|
|
r
|
|
);
|
|
}
|
|
function C(e, t) {
|
|
var n = t.getRootNode && t.getRootNode();
|
|
if (e.contains(t)) return !0;
|
|
if (n && o(n)) {
|
|
var r = t;
|
|
do {
|
|
if (r && e.isSameNode(r)) return !0;
|
|
r = r.parentNode || r.host;
|
|
} while (r);
|
|
}
|
|
return !1;
|
|
}
|
|
function N(e) {
|
|
return Object.assign({}, e, {
|
|
left: e.x,
|
|
top: e.y,
|
|
right: e.x + e.width,
|
|
bottom: e.y + e.height,
|
|
});
|
|
}
|
|
function I(e, r, o) {
|
|
return r === H
|
|
? N(
|
|
(function (e, n) {
|
|
var r = t(e),
|
|
o = d(e),
|
|
i = r.visualViewport,
|
|
a = o.clientWidth,
|
|
s = o.clientHeight,
|
|
f = 0,
|
|
p = 0;
|
|
if (i) {
|
|
(a = i.width), (s = i.height);
|
|
var u = c();
|
|
(u || (!u && "fixed" === n)) &&
|
|
((f = i.offsetLeft), (p = i.offsetTop));
|
|
}
|
|
return { width: a, height: s, x: f + h(e), y: p };
|
|
})(e, o)
|
|
)
|
|
: n(r)
|
|
? (function (e, t) {
|
|
var n = p(e, !1, "fixed" === t);
|
|
return (
|
|
(n.top = n.top + e.clientTop),
|
|
(n.left = n.left + e.clientLeft),
|
|
(n.bottom = n.top + e.clientHeight),
|
|
(n.right = n.left + e.clientWidth),
|
|
(n.width = e.clientWidth),
|
|
(n.height = e.clientHeight),
|
|
(n.x = n.left),
|
|
(n.y = n.top),
|
|
n
|
|
);
|
|
})(r, o)
|
|
: N(
|
|
(function (e) {
|
|
var t,
|
|
n = d(e),
|
|
r = u(e),
|
|
o = null == (t = e.ownerDocument) ? void 0 : t.body,
|
|
a = i(
|
|
n.scrollWidth,
|
|
n.clientWidth,
|
|
o ? o.scrollWidth : 0,
|
|
o ? o.clientWidth : 0
|
|
),
|
|
s = i(
|
|
n.scrollHeight,
|
|
n.clientHeight,
|
|
o ? o.scrollHeight : 0,
|
|
o ? o.clientHeight : 0
|
|
),
|
|
f = -r.scrollLeft + h(e),
|
|
c = -r.scrollTop;
|
|
return (
|
|
"rtl" === m(o || n).direction &&
|
|
(f +=
|
|
i(n.clientWidth, o ? o.clientWidth : 0) - a),
|
|
{ width: a, height: s, x: f, y: c }
|
|
);
|
|
})(d(e))
|
|
);
|
|
}
|
|
function _(e, t, o, s) {
|
|
var f =
|
|
"clippingParents" === t
|
|
? (function (e) {
|
|
var t = w(b(e)),
|
|
o =
|
|
["absolute", "fixed"].indexOf(
|
|
m(e).position
|
|
) >= 0 && r(e)
|
|
? E(e)
|
|
: e;
|
|
return n(o)
|
|
? t.filter(function (e) {
|
|
return n(e) && C(e, o) && "body" !== l(e);
|
|
})
|
|
: [];
|
|
})(e)
|
|
: [].concat(t),
|
|
c = [].concat(f, [o]),
|
|
p = c[0],
|
|
u = c.reduce(function (t, n) {
|
|
var r = I(e, n, s);
|
|
return (
|
|
(t.top = i(r.top, t.top)),
|
|
(t.right = a(r.right, t.right)),
|
|
(t.bottom = a(r.bottom, t.bottom)),
|
|
(t.left = i(r.left, t.left)),
|
|
t
|
|
);
|
|
}, I(e, p, s));
|
|
return (
|
|
(u.width = u.right - u.left),
|
|
(u.height = u.bottom - u.top),
|
|
(u.x = u.left),
|
|
(u.y = u.top),
|
|
u
|
|
);
|
|
}
|
|
function F(e) {
|
|
return e.split("-")[0];
|
|
}
|
|
function U(e) {
|
|
return e.split("-")[1];
|
|
}
|
|
function z(e) {
|
|
return ["top", "bottom"].indexOf(e) >= 0 ? "x" : "y";
|
|
}
|
|
function X(e) {
|
|
var t,
|
|
n = e.reference,
|
|
r = e.element,
|
|
o = e.placement,
|
|
i = o ? F(o) : null,
|
|
a = o ? U(o) : null,
|
|
s = n.x + n.width / 2 - r.width / 2,
|
|
f = n.y + n.height / 2 - r.height / 2;
|
|
switch (i) {
|
|
case D:
|
|
t = { x: s, y: n.y - r.height };
|
|
break;
|
|
case A:
|
|
t = { x: s, y: n.y + n.height };
|
|
break;
|
|
case L:
|
|
t = { x: n.x + n.width, y: f };
|
|
break;
|
|
case P:
|
|
t = { x: n.x - r.width, y: f };
|
|
break;
|
|
default:
|
|
t = { x: n.x, y: n.y };
|
|
}
|
|
var c = i ? z(i) : null;
|
|
if (null != c) {
|
|
var p = "y" === c ? "height" : "width";
|
|
switch (a) {
|
|
case W:
|
|
t[c] = t[c] - (n[p] / 2 - r[p] / 2);
|
|
break;
|
|
case B:
|
|
t[c] = t[c] + (n[p] / 2 - r[p] / 2);
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
function Y(e) {
|
|
return Object.assign({}, { top: 0, right: 0, bottom: 0, left: 0 }, e);
|
|
}
|
|
function G(e, t) {
|
|
return t.reduce(function (t, n) {
|
|
return (t[n] = e), t;
|
|
}, {});
|
|
}
|
|
function J(e, t) {
|
|
void 0 === t && (t = {});
|
|
var r = t,
|
|
o = r.placement,
|
|
i = void 0 === o ? e.placement : o,
|
|
a = r.strategy,
|
|
s = void 0 === a ? e.strategy : a,
|
|
f = r.boundary,
|
|
c = void 0 === f ? "clippingParents" : f,
|
|
u = r.rootBoundary,
|
|
l = void 0 === u ? H : u,
|
|
h = r.elementContext,
|
|
m = void 0 === h ? T : h,
|
|
v = r.altBoundary,
|
|
y = void 0 !== v && v,
|
|
g = r.padding,
|
|
b = void 0 === g ? 0 : g,
|
|
x = Y("number" != typeof b ? b : G(b, k)),
|
|
w = m === T ? "reference" : T,
|
|
O = e.rects.popper,
|
|
j = e.elements[y ? w : m],
|
|
E = _(n(j) ? j : j.contextElement || d(e.elements.popper), c, l, s),
|
|
P = p(e.elements.reference),
|
|
M = X({
|
|
reference: P,
|
|
element: O,
|
|
strategy: "absolute",
|
|
placement: i,
|
|
}),
|
|
W = N(Object.assign({}, O, M)),
|
|
B = m === T ? W : P,
|
|
R = {
|
|
top: E.top - B.top + x.top,
|
|
bottom: B.bottom - E.bottom + x.bottom,
|
|
left: E.left - B.left + x.left,
|
|
right: B.right - E.right + x.right,
|
|
},
|
|
S = e.modifiersData.offset;
|
|
if (m === T && S) {
|
|
var V = S[i];
|
|
Object.keys(R).forEach(function (e) {
|
|
var t = [L, A].indexOf(e) >= 0 ? 1 : -1,
|
|
n = [D, A].indexOf(e) >= 0 ? "y" : "x";
|
|
R[e] += V[n] * t;
|
|
});
|
|
}
|
|
return R;
|
|
}
|
|
var K = { placement: "bottom", modifiers: [], strategy: "absolute" };
|
|
function Q() {
|
|
for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
|
|
t[n] = arguments[n];
|
|
return !t.some(function (e) {
|
|
return !(e && "function" == typeof e.getBoundingClientRect);
|
|
});
|
|
}
|
|
function Z(e) {
|
|
void 0 === e && (e = {});
|
|
var t = e,
|
|
r = t.defaultModifiers,
|
|
o = void 0 === r ? [] : r,
|
|
i = t.defaultOptions,
|
|
a = void 0 === i ? K : i;
|
|
return function (e, t, r) {
|
|
void 0 === r && (r = a);
|
|
var i,
|
|
s,
|
|
f = {
|
|
placement: "bottom",
|
|
orderedModifiers: [],
|
|
options: Object.assign({}, K, a),
|
|
modifiersData: {},
|
|
elements: { reference: e, popper: t },
|
|
attributes: {},
|
|
styles: {},
|
|
},
|
|
c = [],
|
|
p = !1,
|
|
u = {
|
|
state: f,
|
|
setOptions: function (r) {
|
|
var i = "function" == typeof r ? r(f.options) : r;
|
|
l(),
|
|
(f.options = Object.assign({}, a, f.options, i)),
|
|
(f.scrollParents = {
|
|
reference: n(e)
|
|
? w(e)
|
|
: e.contextElement
|
|
? w(e.contextElement)
|
|
: [],
|
|
popper: w(t),
|
|
});
|
|
var s,
|
|
p,
|
|
d = (function (e) {
|
|
var t = q(e);
|
|
return V.reduce(function (e, n) {
|
|
return e.concat(
|
|
t.filter(function (e) {
|
|
return e.phase === n;
|
|
})
|
|
);
|
|
}, []);
|
|
})(
|
|
((s = [].concat(o, f.options.modifiers)),
|
|
(p = s.reduce(function (e, t) {
|
|
var n = e[t.name];
|
|
return (
|
|
(e[t.name] = n
|
|
? Object.assign({}, n, t, {
|
|
options: Object.assign(
|
|
{},
|
|
n.options,
|
|
t.options
|
|
),
|
|
data: Object.assign(
|
|
{},
|
|
n.data,
|
|
t.data
|
|
),
|
|
})
|
|
: t),
|
|
e
|
|
);
|
|
}, {})),
|
|
Object.keys(p).map(function (e) {
|
|
return p[e];
|
|
}))
|
|
);
|
|
return (
|
|
(f.orderedModifiers = d.filter(function (e) {
|
|
return e.enabled;
|
|
})),
|
|
f.orderedModifiers.forEach(function (e) {
|
|
var t = e.name,
|
|
n = e.options,
|
|
r = void 0 === n ? {} : n,
|
|
o = e.effect;
|
|
if ("function" == typeof o) {
|
|
var i = o({
|
|
state: f,
|
|
name: t,
|
|
instance: u,
|
|
options: r,
|
|
}),
|
|
a = function () {};
|
|
c.push(i || a);
|
|
}
|
|
}),
|
|
u.update()
|
|
);
|
|
},
|
|
forceUpdate: function () {
|
|
if (!p) {
|
|
var e = f.elements,
|
|
t = e.reference,
|
|
n = e.popper;
|
|
if (Q(t, n)) {
|
|
(f.rects = {
|
|
reference: y(
|
|
t,
|
|
E(n),
|
|
"fixed" === f.options.strategy
|
|
),
|
|
popper: g(n),
|
|
}),
|
|
(f.reset = !1),
|
|
(f.placement = f.options.placement),
|
|
f.orderedModifiers.forEach(function (e) {
|
|
return (f.modifiersData[e.name] =
|
|
Object.assign({}, e.data));
|
|
});
|
|
for (
|
|
var r = 0;
|
|
r < f.orderedModifiers.length;
|
|
r++
|
|
)
|
|
if (!0 !== f.reset) {
|
|
var o = f.orderedModifiers[r],
|
|
i = o.fn,
|
|
a = o.options,
|
|
s = void 0 === a ? {} : a,
|
|
c = o.name;
|
|
"function" == typeof i &&
|
|
(f =
|
|
i({
|
|
state: f,
|
|
options: s,
|
|
name: c,
|
|
instance: u,
|
|
}) || f);
|
|
} else (f.reset = !1), (r = -1);
|
|
}
|
|
}
|
|
},
|
|
update:
|
|
((i = function () {
|
|
return new Promise(function (e) {
|
|
u.forceUpdate(), e(f);
|
|
});
|
|
}),
|
|
function () {
|
|
return (
|
|
s ||
|
|
(s = new Promise(function (e) {
|
|
Promise.resolve().then(function () {
|
|
(s = void 0), e(i());
|
|
});
|
|
})),
|
|
s
|
|
);
|
|
}),
|
|
destroy: function () {
|
|
l(), (p = !0);
|
|
},
|
|
};
|
|
if (!Q(e, t)) return u;
|
|
function l() {
|
|
c.forEach(function (e) {
|
|
return e();
|
|
}),
|
|
(c = []);
|
|
}
|
|
return (
|
|
u.setOptions(r).then(function (e) {
|
|
!p && r.onFirstUpdate && r.onFirstUpdate(e);
|
|
}),
|
|
u
|
|
);
|
|
};
|
|
}
|
|
var $ = { passive: !0 };
|
|
var ee = {
|
|
name: "eventListeners",
|
|
enabled: !0,
|
|
phase: "write",
|
|
fn: function () {},
|
|
effect: function (e) {
|
|
var n = e.state,
|
|
r = e.instance,
|
|
o = e.options,
|
|
i = o.scroll,
|
|
a = void 0 === i || i,
|
|
s = o.resize,
|
|
f = void 0 === s || s,
|
|
c = t(n.elements.popper),
|
|
p = [].concat(
|
|
n.scrollParents.reference,
|
|
n.scrollParents.popper
|
|
);
|
|
return (
|
|
a &&
|
|
p.forEach(function (e) {
|
|
e.addEventListener("scroll", r.update, $);
|
|
}),
|
|
f && c.addEventListener("resize", r.update, $),
|
|
function () {
|
|
a &&
|
|
p.forEach(function (e) {
|
|
e.removeEventListener("scroll", r.update, $);
|
|
}),
|
|
f && c.removeEventListener("resize", r.update, $);
|
|
}
|
|
);
|
|
},
|
|
data: {},
|
|
};
|
|
var te = {
|
|
name: "popperOffsets",
|
|
enabled: !0,
|
|
phase: "read",
|
|
fn: function (e) {
|
|
var t = e.state,
|
|
n = e.name;
|
|
t.modifiersData[n] = X({
|
|
reference: t.rects.reference,
|
|
element: t.rects.popper,
|
|
strategy: "absolute",
|
|
placement: t.placement,
|
|
});
|
|
},
|
|
data: {},
|
|
},
|
|
ne = { top: "auto", right: "auto", bottom: "auto", left: "auto" };
|
|
function re(e) {
|
|
var n,
|
|
r = e.popper,
|
|
o = e.popperRect,
|
|
i = e.placement,
|
|
a = e.variation,
|
|
f = e.offsets,
|
|
c = e.position,
|
|
p = e.gpuAcceleration,
|
|
u = e.adaptive,
|
|
l = e.roundOffsets,
|
|
h = e.isFixed,
|
|
v = f.x,
|
|
y = void 0 === v ? 0 : v,
|
|
g = f.y,
|
|
b = void 0 === g ? 0 : g,
|
|
x = "function" == typeof l ? l({ x: y, y: b }) : { x: y, y: b };
|
|
(y = x.x), (b = x.y);
|
|
var w = f.hasOwnProperty("x"),
|
|
O = f.hasOwnProperty("y"),
|
|
j = P,
|
|
M = D,
|
|
k = window;
|
|
if (u) {
|
|
var W = E(r),
|
|
H = "clientHeight",
|
|
T = "clientWidth";
|
|
if (
|
|
(W === t(r) &&
|
|
"static" !== m((W = d(r))).position &&
|
|
"absolute" === c &&
|
|
((H = "scrollHeight"), (T = "scrollWidth")),
|
|
(W = W),
|
|
i === D || ((i === P || i === L) && a === B))
|
|
)
|
|
(M = A),
|
|
(b -=
|
|
(h && W === k && k.visualViewport
|
|
? k.visualViewport.height
|
|
: W[H]) - o.height),
|
|
(b *= p ? 1 : -1);
|
|
if (i === P || ((i === D || i === A) && a === B))
|
|
(j = L),
|
|
(y -=
|
|
(h && W === k && k.visualViewport
|
|
? k.visualViewport.width
|
|
: W[T]) - o.width),
|
|
(y *= p ? 1 : -1);
|
|
}
|
|
var R,
|
|
S = Object.assign({ position: c }, u && ne),
|
|
V =
|
|
!0 === l
|
|
? (function (e, t) {
|
|
var n = e.x,
|
|
r = e.y,
|
|
o = t.devicePixelRatio || 1;
|
|
return { x: s(n * o) / o || 0, y: s(r * o) / o || 0 };
|
|
})({ x: y, y: b }, t(r))
|
|
: { x: y, y: b };
|
|
return (
|
|
(y = V.x),
|
|
(b = V.y),
|
|
p
|
|
? Object.assign(
|
|
{},
|
|
S,
|
|
(((R = {})[M] = O ? "0" : ""),
|
|
(R[j] = w ? "0" : ""),
|
|
(R.transform =
|
|
(k.devicePixelRatio || 1) <= 1
|
|
? "translate(" + y + "px, " + b + "px)"
|
|
: "translate3d(" + y + "px, " + b + "px, 0)"),
|
|
R)
|
|
)
|
|
: Object.assign(
|
|
{},
|
|
S,
|
|
(((n = {})[M] = O ? b + "px" : ""),
|
|
(n[j] = w ? y + "px" : ""),
|
|
(n.transform = ""),
|
|
n)
|
|
)
|
|
);
|
|
}
|
|
var oe = {
|
|
name: "computeStyles",
|
|
enabled: !0,
|
|
phase: "beforeWrite",
|
|
fn: function (e) {
|
|
var t = e.state,
|
|
n = e.options,
|
|
r = n.gpuAcceleration,
|
|
o = void 0 === r || r,
|
|
i = n.adaptive,
|
|
a = void 0 === i || i,
|
|
s = n.roundOffsets,
|
|
f = void 0 === s || s,
|
|
c = {
|
|
placement: F(t.placement),
|
|
variation: U(t.placement),
|
|
popper: t.elements.popper,
|
|
popperRect: t.rects.popper,
|
|
gpuAcceleration: o,
|
|
isFixed: "fixed" === t.options.strategy,
|
|
};
|
|
null != t.modifiersData.popperOffsets &&
|
|
(t.styles.popper = Object.assign(
|
|
{},
|
|
t.styles.popper,
|
|
re(
|
|
Object.assign({}, c, {
|
|
offsets: t.modifiersData.popperOffsets,
|
|
position: t.options.strategy,
|
|
adaptive: a,
|
|
roundOffsets: f,
|
|
})
|
|
)
|
|
)),
|
|
null != t.modifiersData.arrow &&
|
|
(t.styles.arrow = Object.assign(
|
|
{},
|
|
t.styles.arrow,
|
|
re(
|
|
Object.assign({}, c, {
|
|
offsets: t.modifiersData.arrow,
|
|
position: "absolute",
|
|
adaptive: !1,
|
|
roundOffsets: f,
|
|
})
|
|
)
|
|
)),
|
|
(t.attributes.popper = Object.assign({}, t.attributes.popper, {
|
|
"data-popper-placement": t.placement,
|
|
}));
|
|
},
|
|
data: {},
|
|
};
|
|
var ie = {
|
|
name: "applyStyles",
|
|
enabled: !0,
|
|
phase: "write",
|
|
fn: function (e) {
|
|
var t = e.state;
|
|
Object.keys(t.elements).forEach(function (e) {
|
|
var n = t.styles[e] || {},
|
|
o = t.attributes[e] || {},
|
|
i = t.elements[e];
|
|
r(i) &&
|
|
l(i) &&
|
|
(Object.assign(i.style, n),
|
|
Object.keys(o).forEach(function (e) {
|
|
var t = o[e];
|
|
!1 === t
|
|
? i.removeAttribute(e)
|
|
: i.setAttribute(e, !0 === t ? "" : t);
|
|
}));
|
|
});
|
|
},
|
|
effect: function (e) {
|
|
var t = e.state,
|
|
n = {
|
|
popper: {
|
|
position: t.options.strategy,
|
|
left: "0",
|
|
top: "0",
|
|
margin: "0",
|
|
},
|
|
arrow: { position: "absolute" },
|
|
reference: {},
|
|
};
|
|
return (
|
|
Object.assign(t.elements.popper.style, n.popper),
|
|
(t.styles = n),
|
|
t.elements.arrow &&
|
|
Object.assign(t.elements.arrow.style, n.arrow),
|
|
function () {
|
|
Object.keys(t.elements).forEach(function (e) {
|
|
var o = t.elements[e],
|
|
i = t.attributes[e] || {},
|
|
a = Object.keys(
|
|
t.styles.hasOwnProperty(e) ? t.styles[e] : n[e]
|
|
).reduce(function (e, t) {
|
|
return (e[t] = ""), e;
|
|
}, {});
|
|
r(o) &&
|
|
l(o) &&
|
|
(Object.assign(o.style, a),
|
|
Object.keys(i).forEach(function (e) {
|
|
o.removeAttribute(e);
|
|
}));
|
|
});
|
|
}
|
|
);
|
|
},
|
|
requires: ["computeStyles"],
|
|
};
|
|
var ae = {
|
|
name: "offset",
|
|
enabled: !0,
|
|
phase: "main",
|
|
requires: ["popperOffsets"],
|
|
fn: function (e) {
|
|
var t = e.state,
|
|
n = e.options,
|
|
r = e.name,
|
|
o = n.offset,
|
|
i = void 0 === o ? [0, 0] : o,
|
|
a = S.reduce(function (e, n) {
|
|
return (
|
|
(e[n] = (function (e, t, n) {
|
|
var r = F(e),
|
|
o = [P, D].indexOf(r) >= 0 ? -1 : 1,
|
|
i =
|
|
"function" == typeof n
|
|
? n(
|
|
Object.assign({}, t, {
|
|
placement: e,
|
|
})
|
|
)
|
|
: n,
|
|
a = i[0],
|
|
s = i[1];
|
|
return (
|
|
(a = a || 0),
|
|
(s = (s || 0) * o),
|
|
[P, L].indexOf(r) >= 0
|
|
? { x: s, y: a }
|
|
: { x: a, y: s }
|
|
);
|
|
})(n, t.rects, i)),
|
|
e
|
|
);
|
|
}, {}),
|
|
s = a[t.placement],
|
|
f = s.x,
|
|
c = s.y;
|
|
null != t.modifiersData.popperOffsets &&
|
|
((t.modifiersData.popperOffsets.x += f),
|
|
(t.modifiersData.popperOffsets.y += c)),
|
|
(t.modifiersData[r] = a);
|
|
},
|
|
},
|
|
se = { left: "right", right: "left", bottom: "top", top: "bottom" };
|
|
function fe(e) {
|
|
return e.replace(/left|right|bottom|top/g, function (e) {
|
|
return se[e];
|
|
});
|
|
}
|
|
var ce = { start: "end", end: "start" };
|
|
function pe(e) {
|
|
return e.replace(/start|end/g, function (e) {
|
|
return ce[e];
|
|
});
|
|
}
|
|
function ue(e, t) {
|
|
void 0 === t && (t = {});
|
|
var n = t,
|
|
r = n.placement,
|
|
o = n.boundary,
|
|
i = n.rootBoundary,
|
|
a = n.padding,
|
|
s = n.flipVariations,
|
|
f = n.allowedAutoPlacements,
|
|
c = void 0 === f ? S : f,
|
|
p = U(r),
|
|
u = p
|
|
? s
|
|
? R
|
|
: R.filter(function (e) {
|
|
return U(e) === p;
|
|
})
|
|
: k,
|
|
l = u.filter(function (e) {
|
|
return c.indexOf(e) >= 0;
|
|
});
|
|
0 === l.length && (l = u);
|
|
var d = l.reduce(function (t, n) {
|
|
return (
|
|
(t[n] = J(e, {
|
|
placement: n,
|
|
boundary: o,
|
|
rootBoundary: i,
|
|
padding: a,
|
|
})[F(n)]),
|
|
t
|
|
);
|
|
}, {});
|
|
return Object.keys(d).sort(function (e, t) {
|
|
return d[e] - d[t];
|
|
});
|
|
}
|
|
var le = {
|
|
name: "flip",
|
|
enabled: !0,
|
|
phase: "main",
|
|
fn: function (e) {
|
|
var t = e.state,
|
|
n = e.options,
|
|
r = e.name;
|
|
if (!t.modifiersData[r]._skip) {
|
|
for (
|
|
var o = n.mainAxis,
|
|
i = void 0 === o || o,
|
|
a = n.altAxis,
|
|
s = void 0 === a || a,
|
|
f = n.fallbackPlacements,
|
|
c = n.padding,
|
|
p = n.boundary,
|
|
u = n.rootBoundary,
|
|
l = n.altBoundary,
|
|
d = n.flipVariations,
|
|
h = void 0 === d || d,
|
|
m = n.allowedAutoPlacements,
|
|
v = t.options.placement,
|
|
y = F(v),
|
|
g =
|
|
f ||
|
|
(y === v || !h
|
|
? [fe(v)]
|
|
: (function (e) {
|
|
if (F(e) === M) return [];
|
|
var t = fe(e);
|
|
return [pe(e), t, pe(t)];
|
|
})(v)),
|
|
b = [v].concat(g).reduce(function (e, n) {
|
|
return e.concat(
|
|
F(n) === M
|
|
? ue(t, {
|
|
placement: n,
|
|
boundary: p,
|
|
rootBoundary: u,
|
|
padding: c,
|
|
flipVariations: h,
|
|
allowedAutoPlacements: m,
|
|
})
|
|
: n
|
|
);
|
|
}, []),
|
|
x = t.rects.reference,
|
|
w = t.rects.popper,
|
|
O = new Map(),
|
|
j = !0,
|
|
E = b[0],
|
|
k = 0;
|
|
k < b.length;
|
|
k++
|
|
) {
|
|
var B = b[k],
|
|
H = F(B),
|
|
T = U(B) === W,
|
|
R = [D, A].indexOf(H) >= 0,
|
|
S = R ? "width" : "height",
|
|
V = J(t, {
|
|
placement: B,
|
|
boundary: p,
|
|
rootBoundary: u,
|
|
altBoundary: l,
|
|
padding: c,
|
|
}),
|
|
q = R ? (T ? L : P) : T ? A : D;
|
|
x[S] > w[S] && (q = fe(q));
|
|
var C = fe(q),
|
|
N = [];
|
|
if (
|
|
(i && N.push(V[H] <= 0),
|
|
s && N.push(V[q] <= 0, V[C] <= 0),
|
|
N.every(function (e) {
|
|
return e;
|
|
}))
|
|
) {
|
|
(E = B), (j = !1);
|
|
break;
|
|
}
|
|
O.set(B, N);
|
|
}
|
|
if (j)
|
|
for (
|
|
var I = function (e) {
|
|
var t = b.find(function (t) {
|
|
var n = O.get(t);
|
|
if (n)
|
|
return n
|
|
.slice(0, e)
|
|
.every(function (e) {
|
|
return e;
|
|
});
|
|
});
|
|
if (t) return (E = t), "break";
|
|
},
|
|
_ = h ? 3 : 1;
|
|
_ > 0;
|
|
_--
|
|
) {
|
|
if ("break" === I(_)) break;
|
|
}
|
|
t.placement !== E &&
|
|
((t.modifiersData[r]._skip = !0),
|
|
(t.placement = E),
|
|
(t.reset = !0));
|
|
}
|
|
},
|
|
requiresIfExists: ["offset"],
|
|
data: { _skip: !1 },
|
|
};
|
|
function de(e, t, n) {
|
|
return i(e, a(t, n));
|
|
}
|
|
var he = {
|
|
name: "preventOverflow",
|
|
enabled: !0,
|
|
phase: "main",
|
|
fn: function (e) {
|
|
var t = e.state,
|
|
n = e.options,
|
|
r = e.name,
|
|
o = n.mainAxis,
|
|
s = void 0 === o || o,
|
|
f = n.altAxis,
|
|
c = void 0 !== f && f,
|
|
p = n.boundary,
|
|
u = n.rootBoundary,
|
|
l = n.altBoundary,
|
|
d = n.padding,
|
|
h = n.tether,
|
|
m = void 0 === h || h,
|
|
v = n.tetherOffset,
|
|
y = void 0 === v ? 0 : v,
|
|
b = J(t, {
|
|
boundary: p,
|
|
rootBoundary: u,
|
|
padding: d,
|
|
altBoundary: l,
|
|
}),
|
|
x = F(t.placement),
|
|
w = U(t.placement),
|
|
O = !w,
|
|
j = z(x),
|
|
M = "x" === j ? "y" : "x",
|
|
k = t.modifiersData.popperOffsets,
|
|
B = t.rects.reference,
|
|
H = t.rects.popper,
|
|
T =
|
|
"function" == typeof y
|
|
? y(
|
|
Object.assign({}, t.rects, {
|
|
placement: t.placement,
|
|
})
|
|
)
|
|
: y,
|
|
R =
|
|
"number" == typeof T
|
|
? { mainAxis: T, altAxis: T }
|
|
: Object.assign({ mainAxis: 0, altAxis: 0 }, T),
|
|
S = t.modifiersData.offset
|
|
? t.modifiersData.offset[t.placement]
|
|
: null,
|
|
V = { x: 0, y: 0 };
|
|
if (k) {
|
|
if (s) {
|
|
var q,
|
|
C = "y" === j ? D : P,
|
|
N = "y" === j ? A : L,
|
|
I = "y" === j ? "height" : "width",
|
|
_ = k[j],
|
|
X = _ + b[C],
|
|
Y = _ - b[N],
|
|
G = m ? -H[I] / 2 : 0,
|
|
K = w === W ? B[I] : H[I],
|
|
Q = w === W ? -H[I] : -B[I],
|
|
Z = t.elements.arrow,
|
|
$ = m && Z ? g(Z) : { width: 0, height: 0 },
|
|
ee = t.modifiersData["arrow#persistent"]
|
|
? t.modifiersData["arrow#persistent"].padding
|
|
: { top: 0, right: 0, bottom: 0, left: 0 },
|
|
te = ee[C],
|
|
ne = ee[N],
|
|
re = de(0, B[I], $[I]),
|
|
oe = O
|
|
? B[I] / 2 - G - re - te - R.mainAxis
|
|
: K - re - te - R.mainAxis,
|
|
ie = O
|
|
? -B[I] / 2 + G + re + ne + R.mainAxis
|
|
: Q + re + ne + R.mainAxis,
|
|
ae = t.elements.arrow && E(t.elements.arrow),
|
|
se = ae
|
|
? "y" === j
|
|
? ae.clientTop || 0
|
|
: ae.clientLeft || 0
|
|
: 0,
|
|
fe = null != (q = null == S ? void 0 : S[j]) ? q : 0,
|
|
ce = _ + ie - fe,
|
|
pe = de(
|
|
m ? a(X, _ + oe - fe - se) : X,
|
|
_,
|
|
m ? i(Y, ce) : Y
|
|
);
|
|
(k[j] = pe), (V[j] = pe - _);
|
|
}
|
|
if (c) {
|
|
var ue,
|
|
le = "x" === j ? D : P,
|
|
he = "x" === j ? A : L,
|
|
me = k[M],
|
|
ve = "y" === M ? "height" : "width",
|
|
ye = me + b[le],
|
|
ge = me - b[he],
|
|
be = -1 !== [D, P].indexOf(x),
|
|
xe = null != (ue = null == S ? void 0 : S[M]) ? ue : 0,
|
|
we = be ? ye : me - B[ve] - H[ve] - xe + R.altAxis,
|
|
Oe = be ? me + B[ve] + H[ve] - xe - R.altAxis : ge,
|
|
je =
|
|
m && be
|
|
? (function (e, t, n) {
|
|
var r = de(e, t, n);
|
|
return r > n ? n : r;
|
|
})(we, me, Oe)
|
|
: de(m ? we : ye, me, m ? Oe : ge);
|
|
(k[M] = je), (V[M] = je - me);
|
|
}
|
|
t.modifiersData[r] = V;
|
|
}
|
|
},
|
|
requiresIfExists: ["offset"],
|
|
};
|
|
var me = {
|
|
name: "arrow",
|
|
enabled: !0,
|
|
phase: "main",
|
|
fn: function (e) {
|
|
var t,
|
|
n = e.state,
|
|
r = e.name,
|
|
o = e.options,
|
|
i = n.elements.arrow,
|
|
a = n.modifiersData.popperOffsets,
|
|
s = F(n.placement),
|
|
f = z(s),
|
|
c = [P, L].indexOf(s) >= 0 ? "height" : "width";
|
|
if (i && a) {
|
|
var p = (function (e, t) {
|
|
return Y(
|
|
"number" !=
|
|
typeof (e =
|
|
"function" == typeof e
|
|
? e(
|
|
Object.assign({}, t.rects, {
|
|
placement: t.placement,
|
|
})
|
|
)
|
|
: e)
|
|
? e
|
|
: G(e, k)
|
|
);
|
|
})(o.padding, n),
|
|
u = g(i),
|
|
l = "y" === f ? D : P,
|
|
d = "y" === f ? A : L,
|
|
h =
|
|
n.rects.reference[c] +
|
|
n.rects.reference[f] -
|
|
a[f] -
|
|
n.rects.popper[c],
|
|
m = a[f] - n.rects.reference[f],
|
|
v = E(i),
|
|
y = v
|
|
? "y" === f
|
|
? v.clientHeight || 0
|
|
: v.clientWidth || 0
|
|
: 0,
|
|
b = h / 2 - m / 2,
|
|
x = p[l],
|
|
w = y - u[c] - p[d],
|
|
O = y / 2 - u[c] / 2 + b,
|
|
j = de(x, O, w),
|
|
M = f;
|
|
n.modifiersData[r] =
|
|
(((t = {})[M] = j), (t.centerOffset = j - O), t);
|
|
}
|
|
},
|
|
effect: function (e) {
|
|
var t = e.state,
|
|
n = e.options.element,
|
|
r = void 0 === n ? "[data-popper-arrow]" : n;
|
|
null != r &&
|
|
("string" != typeof r ||
|
|
(r = t.elements.popper.querySelector(r))) &&
|
|
C(t.elements.popper, r) &&
|
|
(t.elements.arrow = r);
|
|
},
|
|
requires: ["popperOffsets"],
|
|
requiresIfExists: ["preventOverflow"],
|
|
};
|
|
function ve(e, t, n) {
|
|
return (
|
|
void 0 === n && (n = { x: 0, y: 0 }),
|
|
{
|
|
top: e.top - t.height - n.y,
|
|
right: e.right - t.width + n.x,
|
|
bottom: e.bottom - t.height + n.y,
|
|
left: e.left - t.width - n.x,
|
|
}
|
|
);
|
|
}
|
|
function ye(e) {
|
|
return [D, L, A, P].some(function (t) {
|
|
return e[t] >= 0;
|
|
});
|
|
}
|
|
var ge = {
|
|
name: "hide",
|
|
enabled: !0,
|
|
phase: "main",
|
|
requiresIfExists: ["preventOverflow"],
|
|
fn: function (e) {
|
|
var t = e.state,
|
|
n = e.name,
|
|
r = t.rects.reference,
|
|
o = t.rects.popper,
|
|
i = t.modifiersData.preventOverflow,
|
|
a = J(t, { elementContext: "reference" }),
|
|
s = J(t, { altBoundary: !0 }),
|
|
f = ve(a, r),
|
|
c = ve(s, o, i),
|
|
p = ye(f),
|
|
u = ye(c);
|
|
(t.modifiersData[n] = {
|
|
referenceClippingOffsets: f,
|
|
popperEscapeOffsets: c,
|
|
isReferenceHidden: p,
|
|
hasPopperEscaped: u,
|
|
}),
|
|
(t.attributes.popper = Object.assign(
|
|
{},
|
|
t.attributes.popper,
|
|
{
|
|
"data-popper-reference-hidden": p,
|
|
"data-popper-escaped": u,
|
|
}
|
|
));
|
|
},
|
|
},
|
|
be = Z({ defaultModifiers: [ee, te, oe, ie] }),
|
|
xe = [ee, te, oe, ie, ae, le, he, me, ge],
|
|
we = Z({ defaultModifiers: xe });
|
|
(e.applyStyles = ie),
|
|
(e.arrow = me),
|
|
(e.computeStyles = oe),
|
|
(e.createPopper = we),
|
|
(e.createPopperLite = be),
|
|
(e.defaultModifiers = xe),
|
|
(e.detectOverflow = J),
|
|
(e.eventListeners = ee),
|
|
(e.flip = le),
|
|
(e.hide = ge),
|
|
(e.offset = ae),
|
|
(e.popperGenerator = Z),
|
|
(e.popperOffsets = te),
|
|
(e.preventOverflow = he),
|
|
Object.defineProperty(e, "__esModule", { value: !0 });
|
|
});
|
|
//# sourceMappingURL=popper.min.js.map
|