3882 lines
134 KiB
JavaScript
3882 lines
134 KiB
JavaScript
/*!
|
|
* Bootstrap v5.3.0-alpha1 (https://getbootstrap.com/)
|
|
* Copyright 2011-2022 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
|
|
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
|
|
*/
|
|
!function(t, e) {
|
|
"object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).bootstrap = e()
|
|
}(this, (function() {
|
|
"use strict";
|
|
const t = "transitionend"
|
|
, e = t => (t && window.CSS && window.CSS.escape && (t = t.replace(/#([^\s"#']+)/g, ( (t, e) => `#${CSS.escape(e)}`))),
|
|
t)
|
|
, i = e => {
|
|
e.dispatchEvent(new Event(t))
|
|
}
|
|
, n = t => !(!t || "object" != typeof t) && (void 0 !== t.jquery && (t = t[0]),
|
|
void 0 !== t.nodeType)
|
|
, s = t => n(t) ? t.jquery ? t[0] : t : "string" == typeof t && t.length > 0 ? document.querySelector(e(t)) : null
|
|
, o = t => {
|
|
if (!n(t) || 0 === t.getClientRects().length)
|
|
return !1;
|
|
const e = "visible" === getComputedStyle(t).getPropertyValue("visibility")
|
|
, i = t.closest("details:not([open])");
|
|
if (!i)
|
|
return e;
|
|
if (i !== t) {
|
|
const e = t.closest("summary");
|
|
if (e && e.parentNode !== i)
|
|
return !1;
|
|
if (null === e)
|
|
return !1
|
|
}
|
|
return e
|
|
}
|
|
, r = t => !t || t.nodeType !== Node.ELEMENT_NODE || !!t.classList.contains("disabled") || (void 0 !== t.disabled ? t.disabled : t.hasAttribute("disabled") && "false" !== t.getAttribute("disabled"))
|
|
, a = t => {
|
|
if (!document.documentElement.attachShadow)
|
|
return null;
|
|
if ("function" == typeof t.getRootNode) {
|
|
const e = t.getRootNode();
|
|
return e instanceof ShadowRoot ? e : null
|
|
}
|
|
return t instanceof ShadowRoot ? t : t.parentNode ? a(t.parentNode) : null
|
|
}
|
|
, l = () => {}
|
|
, c = t => {
|
|
t.offsetHeight
|
|
}
|
|
, h = () => window.jQuery && !document.body.hasAttribute("data-bs-no-jquery") ? window.jQuery : null
|
|
, d = []
|
|
, u = () => "rtl" === document.documentElement.dir
|
|
, f = t => {
|
|
var e;
|
|
e = () => {
|
|
const e = h();
|
|
if (e) {
|
|
const i = t.NAME
|
|
, n = e.fn[i];
|
|
e.fn[i] = t.jQueryInterface,
|
|
e.fn[i].Constructor = t,
|
|
e.fn[i].noConflict = () => (e.fn[i] = n,
|
|
t.jQueryInterface)
|
|
}
|
|
}
|
|
,
|
|
"loading" === document.readyState ? (d.length || document.addEventListener("DOMContentLoaded", ( () => {
|
|
for (const t of d)
|
|
t()
|
|
}
|
|
)),
|
|
d.push(e)) : e()
|
|
}
|
|
, p = (t, e=[], i=t) => "function" == typeof t ? t(...e) : i
|
|
, m = (e, n, s=!0) => {
|
|
if (!s)
|
|
return void p(e);
|
|
const o = (t => {
|
|
if (!t)
|
|
return 0;
|
|
let {transitionDuration: e, transitionDelay: i} = window.getComputedStyle(t);
|
|
const n = Number.parseFloat(e)
|
|
, s = Number.parseFloat(i);
|
|
return n || s ? (e = e.split(",")[0],
|
|
i = i.split(",")[0],
|
|
1e3 * (Number.parseFloat(e) + Number.parseFloat(i))) : 0
|
|
}
|
|
)(n) + 5;
|
|
let r = !1;
|
|
const a = ({target: i}) => {
|
|
i === n && (r = !0,
|
|
n.removeEventListener(t, a),
|
|
p(e))
|
|
}
|
|
;
|
|
n.addEventListener(t, a),
|
|
setTimeout(( () => {
|
|
r || i(n)
|
|
}
|
|
), o)
|
|
}
|
|
, g = (t, e, i, n) => {
|
|
const s = t.length;
|
|
let o = t.indexOf(e);
|
|
return -1 === o ? !i && n ? t[s - 1] : t[0] : (o += i ? 1 : -1,
|
|
n && (o = (o + s) % s),
|
|
t[Math.max(0, Math.min(o, s - 1))])
|
|
}
|
|
, _ = /[^.]*(?=\..*)\.|.*/
|
|
, b = /\..*/
|
|
, v = /::\d+$/
|
|
, y = {};
|
|
let w = 1;
|
|
const A = {
|
|
mouseenter: "mouseover",
|
|
mouseleave: "mouseout"
|
|
}
|
|
, E = new Set(["click", "dblclick", "mouseup", "mousedown", "contextmenu", "mousewheel", "DOMMouseScroll", "mouseover", "mouseout", "mousemove", "selectstart", "selectend", "keydown", "keypress", "keyup", "orientationchange", "touchstart", "touchmove", "touchend", "touchcancel", "pointerdown", "pointermove", "pointerup", "pointerleave", "pointercancel", "gesturestart", "gesturechange", "gestureend", "focus", "blur", "change", "reset", "select", "submit", "focusin", "focusout", "load", "unload", "beforeunload", "resize", "move", "DOMContentLoaded", "readystatechange", "error", "abort", "scroll"]);
|
|
function T(t, e) {
|
|
return e && `${e}::${w++}` || t.uidEvent || w++
|
|
}
|
|
function C(t) {
|
|
const e = T(t);
|
|
return t.uidEvent = e,
|
|
y[e] = y[e] || {},
|
|
y[e]
|
|
}
|
|
function O(t, e, i=null) {
|
|
return Object.values(t).find((t => t.callable === e && t.delegationSelector === i))
|
|
}
|
|
function x(t, e, i) {
|
|
const n = "string" == typeof e
|
|
, s = n ? i : e || i;
|
|
let o = D(t);
|
|
return E.has(o) || (o = t),
|
|
[n, s, o]
|
|
}
|
|
function k(t, e, i, n, s) {
|
|
if ("string" != typeof e || !t)
|
|
return;
|
|
let[o,r,a] = x(e, i, n);
|
|
if (e in A) {
|
|
const t = t => function(e) {
|
|
if (!e.relatedTarget || e.relatedTarget !== e.delegateTarget && !e.delegateTarget.contains(e.relatedTarget))
|
|
return t.call(this, e)
|
|
}
|
|
;
|
|
r = t(r)
|
|
}
|
|
const l = C(t)
|
|
, c = l[a] || (l[a] = {})
|
|
, h = O(c, r, o ? i : null);
|
|
if (h)
|
|
return void (h.oneOff = h.oneOff && s);
|
|
const d = T(r, e.replace(_, ""))
|
|
, u = o ? function(t, e, i) {
|
|
return function n(s) {
|
|
const o = t.querySelectorAll(e);
|
|
for (let {target: r} = s; r && r !== this; r = r.parentNode)
|
|
for (const a of o)
|
|
if (a === r)
|
|
return N(s, {
|
|
delegateTarget: r
|
|
}),
|
|
n.oneOff && I.off(t, s.type, e, i),
|
|
i.apply(r, [s])
|
|
}
|
|
}(t, i, r) : function(t, e) {
|
|
return function i(n) {
|
|
return N(n, {
|
|
delegateTarget: t
|
|
}),
|
|
i.oneOff && I.off(t, n.type, e),
|
|
e.apply(t, [n])
|
|
}
|
|
}(t, r);
|
|
u.delegationSelector = o ? i : null,
|
|
u.callable = r,
|
|
u.oneOff = s,
|
|
u.uidEvent = d,
|
|
c[d] = u,
|
|
t.addEventListener(a, u, o)
|
|
}
|
|
function L(t, e, i, n, s) {
|
|
const o = O(e[i], n, s);
|
|
o && (t.removeEventListener(i, o, Boolean(s)),
|
|
delete e[i][o.uidEvent])
|
|
}
|
|
function S(t, e, i, n) {
|
|
const s = e[i] || {};
|
|
for (const [o,r] of Object.entries(s))
|
|
o.includes(n) && L(t, e, i, r.callable, r.delegationSelector)
|
|
}
|
|
function D(t) {
|
|
return t = t.replace(b, ""),
|
|
A[t] || t
|
|
}
|
|
const I = {
|
|
on(t, e, i, n) {
|
|
k(t, e, i, n, !1)
|
|
},
|
|
one(t, e, i, n) {
|
|
k(t, e, i, n, !0)
|
|
},
|
|
off(t, e, i, n) {
|
|
if ("string" != typeof e || !t)
|
|
return;
|
|
const [s,o,r] = x(e, i, n)
|
|
, a = r !== e
|
|
, l = C(t)
|
|
, c = l[r] || {}
|
|
, h = e.startsWith(".");
|
|
if (void 0 === o) {
|
|
if (h)
|
|
for (const i of Object.keys(l))
|
|
S(t, l, i, e.slice(1));
|
|
for (const [i,n] of Object.entries(c)) {
|
|
const s = i.replace(v, "");
|
|
a && !e.includes(s) || L(t, l, r, n.callable, n.delegationSelector)
|
|
}
|
|
} else {
|
|
if (!Object.keys(c).length)
|
|
return;
|
|
L(t, l, r, o, s ? i : null)
|
|
}
|
|
},
|
|
trigger(t, e, i) {
|
|
if ("string" != typeof e || !t)
|
|
return null;
|
|
const n = h();
|
|
let s = null
|
|
, o = !0
|
|
, r = !0
|
|
, a = !1;
|
|
e !== D(e) && n && (s = n.Event(e, i),
|
|
n(t).trigger(s),
|
|
o = !s.isPropagationStopped(),
|
|
r = !s.isImmediatePropagationStopped(),
|
|
a = s.isDefaultPrevented());
|
|
let l = new Event(e,{
|
|
bubbles: o,
|
|
cancelable: !0
|
|
});
|
|
return l = N(l, i),
|
|
a && l.preventDefault(),
|
|
r && t.dispatchEvent(l),
|
|
l.defaultPrevented && s && s.preventDefault(),
|
|
l
|
|
}
|
|
};
|
|
function N(t, e={}) {
|
|
for (const [i,n] of Object.entries(e))
|
|
try {
|
|
t[i] = n
|
|
} catch (e) {
|
|
Object.defineProperty(t, i, {
|
|
configurable: !0,
|
|
get: () => n
|
|
})
|
|
}
|
|
return t
|
|
}
|
|
const P = new Map
|
|
, j = {
|
|
set(t, e, i) {
|
|
P.has(t) || P.set(t, new Map);
|
|
const n = P.get(t);
|
|
n.has(e) || 0 === n.size ? n.set(e, i) : console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(n.keys())[0]}.`)
|
|
},
|
|
get: (t, e) => P.has(t) && P.get(t).get(e) || null,
|
|
remove(t, e) {
|
|
if (!P.has(t))
|
|
return;
|
|
const i = P.get(t);
|
|
i.delete(e),
|
|
0 === i.size && P.delete(t)
|
|
}
|
|
};
|
|
function M(t) {
|
|
if ("true" === t)
|
|
return !0;
|
|
if ("false" === t)
|
|
return !1;
|
|
if (t === Number(t).toString())
|
|
return Number(t);
|
|
if ("" === t || "null" === t)
|
|
return null;
|
|
if ("string" != typeof t)
|
|
return t;
|
|
try {
|
|
return JSON.parse(decodeURIComponent(t))
|
|
} catch (e) {
|
|
return t
|
|
}
|
|
}
|
|
function F(t) {
|
|
return t.replace(/[A-Z]/g, (t => `-${t.toLowerCase()}`))
|
|
}
|
|
const H = {
|
|
setDataAttribute(t, e, i) {
|
|
t.setAttribute(`data-bs-${F(e)}`, i)
|
|
},
|
|
removeDataAttribute(t, e) {
|
|
t.removeAttribute(`data-bs-${F(e)}`)
|
|
},
|
|
getDataAttributes(t) {
|
|
if (!t)
|
|
return {};
|
|
const e = {}
|
|
, i = Object.keys(t.dataset).filter((t => t.startsWith("bs") && !t.startsWith("bsConfig")));
|
|
for (const n of i) {
|
|
let i = n.replace(/^bs/, "");
|
|
i = i.charAt(0).toLowerCase() + i.slice(1, i.length),
|
|
e[i] = M(t.dataset[n])
|
|
}
|
|
return e
|
|
},
|
|
getDataAttribute: (t, e) => M(t.getAttribute(`data-bs-${F(e)}`))
|
|
};
|
|
class $ {
|
|
static get Default() {
|
|
return {}
|
|
}
|
|
static get DefaultType() {
|
|
return {}
|
|
}
|
|
static get NAME() {
|
|
throw new Error('You have to implement the static method "NAME", for each component!')
|
|
}
|
|
_getConfig(t) {
|
|
return t = this._mergeConfigObj(t),
|
|
t = this._configAfterMerge(t),
|
|
this._typeCheckConfig(t),
|
|
t
|
|
}
|
|
_configAfterMerge(t) {
|
|
return t
|
|
}
|
|
_mergeConfigObj(t, e) {
|
|
const i = n(e) ? H.getDataAttribute(e, "config") : {};
|
|
return {
|
|
...this.constructor.Default,
|
|
..."object" == typeof i ? i : {},
|
|
...n(e) ? H.getDataAttributes(e) : {},
|
|
..."object" == typeof t ? t : {}
|
|
}
|
|
}
|
|
_typeCheckConfig(t, e=this.constructor.DefaultType) {
|
|
for (const [s,o] of Object.entries(e)) {
|
|
const e = t[s]
|
|
, r = n(e) ? "element" : null == (i = e) ? `${i}` : Object.prototype.toString.call(i).match(/\s([a-z]+)/i)[1].toLowerCase();
|
|
if (!new RegExp(o).test(r))
|
|
throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${s}" provided type "${r}" but expected type "${o}".`)
|
|
}
|
|
var i
|
|
}
|
|
}
|
|
class W extends $ {
|
|
constructor(t, e) {
|
|
super(),
|
|
(t = s(t)) && (this._element = t,
|
|
this._config = this._getConfig(e),
|
|
j.set(this._element, this.constructor.DATA_KEY, this))
|
|
}
|
|
dispose() {
|
|
j.remove(this._element, this.constructor.DATA_KEY),
|
|
I.off(this._element, this.constructor.EVENT_KEY);
|
|
for (const t of Object.getOwnPropertyNames(this))
|
|
this[t] = null
|
|
}
|
|
_queueCallback(t, e, i=!0) {
|
|
m(t, e, i)
|
|
}
|
|
_getConfig(t) {
|
|
return t = this._mergeConfigObj(t, this._element),
|
|
t = this._configAfterMerge(t),
|
|
this._typeCheckConfig(t),
|
|
t
|
|
}
|
|
static getInstance(t) {
|
|
return j.get(s(t), this.DATA_KEY)
|
|
}
|
|
static getOrCreateInstance(t, e={}) {
|
|
return this.getInstance(t) || new this(t,"object" == typeof e ? e : null)
|
|
}
|
|
static get VERSION() {
|
|
return "5.3.0-alpha1"
|
|
}
|
|
static get DATA_KEY() {
|
|
return `bs.${this.NAME}`
|
|
}
|
|
static get EVENT_KEY() {
|
|
return `.${this.DATA_KEY}`
|
|
}
|
|
static eventName(t) {
|
|
return `${t}${this.EVENT_KEY}`
|
|
}
|
|
}
|
|
const B = t => {
|
|
let i = t.getAttribute("data-bs-target");
|
|
if (!i || "#" === i) {
|
|
let e = t.getAttribute("href");
|
|
if (!e || !e.includes("#") && !e.startsWith("."))
|
|
return null;
|
|
e.includes("#") && !e.startsWith("#") && (e = `#${e.split("#")[1]}`),
|
|
i = e && "#" !== e ? e.trim() : null
|
|
}
|
|
return e(i)
|
|
}
|
|
, z = {
|
|
find: (t, e=document.documentElement) => [].concat(...Element.prototype.querySelectorAll.call(e, t)),
|
|
findOne: (t, e=document.documentElement) => Element.prototype.querySelector.call(e, t),
|
|
children: (t, e) => [].concat(...t.children).filter((t => t.matches(e))),
|
|
parents(t, e) {
|
|
const i = [];
|
|
let n = t.parentNode.closest(e);
|
|
for (; n; )
|
|
i.push(n),
|
|
n = n.parentNode.closest(e);
|
|
return i
|
|
},
|
|
prev(t, e) {
|
|
let i = t.previousElementSibling;
|
|
for (; i; ) {
|
|
if (i.matches(e))
|
|
return [i];
|
|
i = i.previousElementSibling
|
|
}
|
|
return []
|
|
},
|
|
next(t, e) {
|
|
let i = t.nextElementSibling;
|
|
for (; i; ) {
|
|
if (i.matches(e))
|
|
return [i];
|
|
i = i.nextElementSibling
|
|
}
|
|
return []
|
|
},
|
|
focusableChildren(t) {
|
|
const e = ["a", "button", "input", "textarea", "select", "details", "[tabindex]", '[contenteditable="true"]'].map((t => `${t}:not([tabindex^="-"])`)).join(",");
|
|
return this.find(e, t).filter((t => !r(t) && o(t)))
|
|
},
|
|
getSelectorFromElement(t) {
|
|
const e = B(t);
|
|
return e && z.findOne(e) ? e : null
|
|
},
|
|
getElementFromSelector(t) {
|
|
const e = B(t);
|
|
return e ? z.findOne(e) : null
|
|
},
|
|
getMultipleElementsFromSelector(t) {
|
|
const e = B(t);
|
|
return e ? z.find(e) : []
|
|
}
|
|
}
|
|
, R = (t, e="hide") => {
|
|
const i = `click.dismiss${t.EVENT_KEY}`
|
|
, n = t.NAME;
|
|
I.on(document, i, `[data-bs-dismiss="${n}"]`, (function(i) {
|
|
if (["A", "AREA"].includes(this.tagName) && i.preventDefault(),
|
|
r(this))
|
|
return;
|
|
const s = z.getElementFromSelector(this) || this.closest(`.${n}`);
|
|
t.getOrCreateInstance(s)[e]()
|
|
}
|
|
))
|
|
}
|
|
;
|
|
class q extends W {
|
|
static get NAME() {
|
|
return "alert"
|
|
}
|
|
close() {
|
|
if (I.trigger(this._element, "close.bs.alert").defaultPrevented)
|
|
return;
|
|
this._element.classList.remove("show");
|
|
const t = this._element.classList.contains("fade");
|
|
this._queueCallback(( () => this._destroyElement()), this._element, t)
|
|
}
|
|
_destroyElement() {
|
|
this._element.remove(),
|
|
I.trigger(this._element, "closed.bs.alert"),
|
|
this.dispose()
|
|
}
|
|
static jQueryInterface(t) {
|
|
return this.each((function() {
|
|
const e = q.getOrCreateInstance(this);
|
|
if ("string" == typeof t) {
|
|
if (void 0 === e[t] || t.startsWith("_") || "constructor" === t)
|
|
throw new TypeError(`No method named "${t}"`);
|
|
e[t](this)
|
|
}
|
|
}
|
|
))
|
|
}
|
|
}
|
|
R(q, "close"),
|
|
f(q);
|
|
const V = '[data-bs-toggle="button"]';
|
|
class K extends W {
|
|
static get NAME() {
|
|
return "button"
|
|
}
|
|
toggle() {
|
|
this._element.setAttribute("aria-pressed", this._element.classList.toggle("active"))
|
|
}
|
|
static jQueryInterface(t) {
|
|
return this.each((function() {
|
|
const e = K.getOrCreateInstance(this);
|
|
"toggle" === t && e[t]()
|
|
}
|
|
))
|
|
}
|
|
}
|
|
I.on(document, "click.bs.button.data-api", V, (t => {
|
|
t.preventDefault();
|
|
const e = t.target.closest(V);
|
|
K.getOrCreateInstance(e).toggle()
|
|
}
|
|
)),
|
|
f(K);
|
|
const Q = {
|
|
endCallback: null,
|
|
leftCallback: null,
|
|
rightCallback: null
|
|
}
|
|
, X = {
|
|
endCallback: "(function|null)",
|
|
leftCallback: "(function|null)",
|
|
rightCallback: "(function|null)"
|
|
};
|
|
class Y extends $ {
|
|
constructor(t, e) {
|
|
super(),
|
|
this._element = t,
|
|
t && Y.isSupported() && (this._config = this._getConfig(e),
|
|
this._deltaX = 0,
|
|
this._supportPointerEvents = Boolean(window.PointerEvent),
|
|
this._initEvents())
|
|
}
|
|
static get Default() {
|
|
return Q
|
|
}
|
|
static get DefaultType() {
|
|
return X
|
|
}
|
|
static get NAME() {
|
|
return "swipe"
|
|
}
|
|
dispose() {
|
|
I.off(this._element, ".bs.swipe")
|
|
}
|
|
_start(t) {
|
|
this._supportPointerEvents ? this._eventIsPointerPenTouch(t) && (this._deltaX = t.clientX) : this._deltaX = t.touches[0].clientX
|
|
}
|
|
_end(t) {
|
|
this._eventIsPointerPenTouch(t) && (this._deltaX = t.clientX - this._deltaX),
|
|
this._handleSwipe(),
|
|
p(this._config.endCallback)
|
|
}
|
|
_move(t) {
|
|
this._deltaX = t.touches && t.touches.length > 1 ? 0 : t.touches[0].clientX - this._deltaX
|
|
}
|
|
_handleSwipe() {
|
|
const t = Math.abs(this._deltaX);
|
|
if (t <= 40)
|
|
return;
|
|
const e = t / this._deltaX;
|
|
this._deltaX = 0,
|
|
e && p(e > 0 ? this._config.rightCallback : this._config.leftCallback)
|
|
}
|
|
_initEvents() {
|
|
this._supportPointerEvents ? (I.on(this._element, "pointerdown.bs.swipe", (t => this._start(t))),
|
|
I.on(this._element, "pointerup.bs.swipe", (t => this._end(t))),
|
|
this._element.classList.add("pointer-event")) : (I.on(this._element, "touchstart.bs.swipe", (t => this._start(t))),
|
|
I.on(this._element, "touchmove.bs.swipe", (t => this._move(t))),
|
|
I.on(this._element, "touchend.bs.swipe", (t => this._end(t))))
|
|
}
|
|
_eventIsPointerPenTouch(t) {
|
|
return this._supportPointerEvents && ("pen" === t.pointerType || "touch" === t.pointerType)
|
|
}
|
|
static isSupported() {
|
|
return "ontouchstart"in document.documentElement || navigator.maxTouchPoints > 0
|
|
}
|
|
}
|
|
const U = "next"
|
|
, G = "prev"
|
|
, J = "left"
|
|
, Z = "right"
|
|
, tt = "slid.bs.carousel"
|
|
, et = "carousel"
|
|
, it = "active"
|
|
, nt = {
|
|
ArrowLeft: Z,
|
|
ArrowRight: J
|
|
}
|
|
, st = {
|
|
interval: 5e3,
|
|
keyboard: !0,
|
|
pause: "hover",
|
|
ride: !1,
|
|
touch: !0,
|
|
wrap: !0
|
|
}
|
|
, ot = {
|
|
interval: "(number|boolean)",
|
|
keyboard: "boolean",
|
|
pause: "(string|boolean)",
|
|
ride: "(boolean|string)",
|
|
touch: "boolean",
|
|
wrap: "boolean"
|
|
};
|
|
class rt extends W {
|
|
constructor(t, e) {
|
|
super(t, e),
|
|
this._interval = null,
|
|
this._activeElement = null,
|
|
this._isSliding = !1,
|
|
this.touchTimeout = null,
|
|
this._swipeHelper = null,
|
|
this._indicatorsElement = z.findOne(".carousel-indicators", this._element),
|
|
this._addEventListeners(),
|
|
this._config.ride === et && this.cycle()
|
|
}
|
|
static get Default() {
|
|
return st
|
|
}
|
|
static get DefaultType() {
|
|
return ot
|
|
}
|
|
static get NAME() {
|
|
return "carousel"
|
|
}
|
|
next() {
|
|
this._slide(U)
|
|
}
|
|
nextWhenVisible() {
|
|
!document.hidden && o(this._element) && this.next()
|
|
}
|
|
prev() {
|
|
this._slide(G)
|
|
}
|
|
pause() {
|
|
this._isSliding && i(this._element),
|
|
this._clearInterval()
|
|
}
|
|
cycle() {
|
|
this._clearInterval(),
|
|
this._updateInterval(),
|
|
this._interval = setInterval(( () => this.nextWhenVisible()), this._config.interval)
|
|
}
|
|
_maybeEnableCycle() {
|
|
this._config.ride && (this._isSliding ? I.one(this._element, tt, ( () => this.cycle())) : this.cycle())
|
|
}
|
|
to(t) {
|
|
const e = this._getItems();
|
|
if (t > e.length - 1 || t < 0)
|
|
return;
|
|
if (this._isSliding)
|
|
return void I.one(this._element, tt, ( () => this.to(t)));
|
|
const i = this._getItemIndex(this._getActive());
|
|
if (i === t)
|
|
return;
|
|
const n = t > i ? U : G;
|
|
this._slide(n, e[t])
|
|
}
|
|
dispose() {
|
|
this._swipeHelper && this._swipeHelper.dispose(),
|
|
super.dispose()
|
|
}
|
|
_configAfterMerge(t) {
|
|
return t.defaultInterval = t.interval,
|
|
t
|
|
}
|
|
_addEventListeners() {
|
|
this._config.keyboard && I.on(this._element, "keydown.bs.carousel", (t => this._keydown(t))),
|
|
"hover" === this._config.pause && (I.on(this._element, "mouseenter.bs.carousel", ( () => this.pause())),
|
|
I.on(this._element, "mouseleave.bs.carousel", ( () => this._maybeEnableCycle()))),
|
|
this._config.touch && Y.isSupported() && this._addTouchEventListeners()
|
|
}
|
|
_addTouchEventListeners() {
|
|
for (const t of z.find(".carousel-item img", this._element))
|
|
I.on(t, "dragstart.bs.carousel", (t => t.preventDefault()));
|
|
const t = {
|
|
leftCallback: () => this._slide(this._directionToOrder(J)),
|
|
rightCallback: () => this._slide(this._directionToOrder(Z)),
|
|
endCallback: () => {
|
|
"hover" === this._config.pause && (this.pause(),
|
|
this.touchTimeout && clearTimeout(this.touchTimeout),
|
|
this.touchTimeout = setTimeout(( () => this._maybeEnableCycle()), 500 + this._config.interval))
|
|
}
|
|
};
|
|
this._swipeHelper = new Y(this._element,t)
|
|
}
|
|
_keydown(t) {
|
|
if (/input|textarea/i.test(t.target.tagName))
|
|
return;
|
|
const e = nt[t.key];
|
|
e && (t.preventDefault(),
|
|
this._slide(this._directionToOrder(e)))
|
|
}
|
|
_getItemIndex(t) {
|
|
return this._getItems().indexOf(t)
|
|
}
|
|
_setActiveIndicatorElement(t) {
|
|
if (!this._indicatorsElement)
|
|
return;
|
|
const e = z.findOne(".active", this._indicatorsElement);
|
|
e.classList.remove(it),
|
|
e.removeAttribute("aria-current");
|
|
const i = z.findOne(`[data-bs-slide-to="${t}"]`, this._indicatorsElement);
|
|
i && (i.classList.add(it),
|
|
i.setAttribute("aria-current", "true"))
|
|
}
|
|
_updateInterval() {
|
|
const t = this._activeElement || this._getActive();
|
|
if (!t)
|
|
return;
|
|
const e = Number.parseInt(t.getAttribute("data-bs-interval"), 10);
|
|
this._config.interval = e || this._config.defaultInterval
|
|
}
|
|
_slide(t, e=null) {
|
|
if (this._isSliding)
|
|
return;
|
|
const i = this._getActive()
|
|
, n = t === U
|
|
, s = e || g(this._getItems(), i, n, this._config.wrap);
|
|
if (s === i)
|
|
return;
|
|
const o = this._getItemIndex(s)
|
|
, r = e => I.trigger(this._element, e, {
|
|
relatedTarget: s,
|
|
direction: this._orderToDirection(t),
|
|
from: this._getItemIndex(i),
|
|
to: o
|
|
});
|
|
if (r("slide.bs.carousel").defaultPrevented)
|
|
return;
|
|
if (!i || !s)
|
|
return;
|
|
const a = Boolean(this._interval);
|
|
this.pause(),
|
|
this._isSliding = !0,
|
|
this._setActiveIndicatorElement(o),
|
|
this._activeElement = s;
|
|
const l = n ? "carousel-item-start" : "carousel-item-end"
|
|
, h = n ? "carousel-item-next" : "carousel-item-prev";
|
|
s.classList.add(h),
|
|
c(s),
|
|
i.classList.add(l),
|
|
s.classList.add(l),
|
|
this._queueCallback(( () => {
|
|
s.classList.remove(l, h),
|
|
s.classList.add(it),
|
|
i.classList.remove(it, h, l),
|
|
this._isSliding = !1,
|
|
r(tt)
|
|
}
|
|
), i, this._isAnimated()),
|
|
a && this.cycle()
|
|
}
|
|
_isAnimated() {
|
|
return this._element.classList.contains("slide")
|
|
}
|
|
_getActive() {
|
|
return z.findOne(".active.carousel-item", this._element)
|
|
}
|
|
_getItems() {
|
|
return z.find(".carousel-item", this._element)
|
|
}
|
|
_clearInterval() {
|
|
this._interval && (clearInterval(this._interval),
|
|
this._interval = null)
|
|
}
|
|
_directionToOrder(t) {
|
|
return u() ? t === J ? G : U : t === J ? U : G
|
|
}
|
|
_orderToDirection(t) {
|
|
return u() ? t === G ? J : Z : t === G ? Z : J
|
|
}
|
|
static jQueryInterface(t) {
|
|
return this.each((function() {
|
|
const e = rt.getOrCreateInstance(this, t);
|
|
if ("number" != typeof t) {
|
|
if ("string" == typeof t) {
|
|
if (void 0 === e[t] || t.startsWith("_") || "constructor" === t)
|
|
throw new TypeError(`No method named "${t}"`);
|
|
e[t]()
|
|
}
|
|
} else
|
|
e.to(t)
|
|
}
|
|
))
|
|
}
|
|
}
|
|
I.on(document, "click.bs.carousel.data-api", "[data-bs-slide], [data-bs-slide-to]", (function(t) {
|
|
const e = z.getElementFromSelector(this);
|
|
if (!e || !e.classList.contains(et))
|
|
return;
|
|
t.preventDefault();
|
|
const i = rt.getOrCreateInstance(e)
|
|
, n = this.getAttribute("data-bs-slide-to");
|
|
return n ? (i.to(n),
|
|
void i._maybeEnableCycle()) : "next" === H.getDataAttribute(this, "slide") ? (i.next(),
|
|
void i._maybeEnableCycle()) : (i.prev(),
|
|
void i._maybeEnableCycle())
|
|
}
|
|
)),
|
|
I.on(window, "load.bs.carousel.data-api", ( () => {
|
|
const t = z.find('[data-bs-ride="carousel"]');
|
|
for (const e of t)
|
|
rt.getOrCreateInstance(e)
|
|
}
|
|
)),
|
|
f(rt);
|
|
const at = "show"
|
|
, lt = "collapse"
|
|
, ct = "collapsing"
|
|
, ht = '[data-bs-toggle="collapse"]'
|
|
, dt = {
|
|
parent: null,
|
|
toggle: !0
|
|
}
|
|
, ut = {
|
|
parent: "(null|element)",
|
|
toggle: "boolean"
|
|
};
|
|
class ft extends W {
|
|
constructor(t, e) {
|
|
super(t, e),
|
|
this._isTransitioning = !1,
|
|
this._triggerArray = [];
|
|
const i = z.find(ht);
|
|
for (const t of i) {
|
|
const e = z.getSelectorFromElement(t)
|
|
, i = z.find(e).filter((t => t === this._element));
|
|
null !== e && i.length && this._triggerArray.push(t)
|
|
}
|
|
this._initializeChildren(),
|
|
this._config.parent || this._addAriaAndCollapsedClass(this._triggerArray, this._isShown()),
|
|
this._config.toggle && this.toggle()
|
|
}
|
|
static get Default() {
|
|
return dt
|
|
}
|
|
static get DefaultType() {
|
|
return ut
|
|
}
|
|
static get NAME() {
|
|
return "collapse"
|
|
}
|
|
toggle() {
|
|
this._isShown() ? this.hide() : this.show()
|
|
}
|
|
show() {
|
|
if (this._isTransitioning || this._isShown())
|
|
return;
|
|
let t = [];
|
|
if (this._config.parent && (t = this._getFirstLevelChildren(".collapse.show, .collapse.collapsing").filter((t => t !== this._element)).map((t => ft.getOrCreateInstance(t, {
|
|
toggle: !1
|
|
})))),
|
|
t.length && t[0]._isTransitioning)
|
|
return;
|
|
if (I.trigger(this._element, "show.bs.collapse").defaultPrevented)
|
|
return;
|
|
for (const e of t)
|
|
e.hide();
|
|
const e = this._getDimension();
|
|
this._element.classList.remove(lt),
|
|
this._element.classList.add(ct),
|
|
this._element.style[e] = 0,
|
|
this._addAriaAndCollapsedClass(this._triggerArray, !0),
|
|
this._isTransitioning = !0;
|
|
const i = `scroll${e[0].toUpperCase() + e.slice(1)}`;
|
|
this._queueCallback(( () => {
|
|
this._isTransitioning = !1,
|
|
this._element.classList.remove(ct),
|
|
this._element.classList.add(lt, at),
|
|
this._element.style[e] = "",
|
|
I.trigger(this._element, "shown.bs.collapse")
|
|
}
|
|
), this._element, !0),
|
|
this._element.style[e] = `${this._element[i]}px`
|
|
}
|
|
hide() {
|
|
if (this._isTransitioning || !this._isShown())
|
|
return;
|
|
if (I.trigger(this._element, "hide.bs.collapse").defaultPrevented)
|
|
return;
|
|
const t = this._getDimension();
|
|
this._element.style[t] = `${this._element.getBoundingClientRect()[t]}px`,
|
|
c(this._element),
|
|
this._element.classList.add(ct),
|
|
this._element.classList.remove(lt, at);
|
|
for (const t of this._triggerArray) {
|
|
const e = z.getElementFromSelector(t);
|
|
e && !this._isShown(e) && this._addAriaAndCollapsedClass([t], !1)
|
|
}
|
|
this._isTransitioning = !0,
|
|
this._element.style[t] = "",
|
|
this._queueCallback(( () => {
|
|
this._isTransitioning = !1,
|
|
this._element.classList.remove(ct),
|
|
this._element.classList.add(lt),
|
|
I.trigger(this._element, "hidden.bs.collapse")
|
|
}
|
|
), this._element, !0)
|
|
}
|
|
_isShown(t=this._element) {
|
|
return t.classList.contains(at)
|
|
}
|
|
_configAfterMerge(t) {
|
|
return t.toggle = Boolean(t.toggle),
|
|
t.parent = s(t.parent),
|
|
t
|
|
}
|
|
_getDimension() {
|
|
return this._element.classList.contains("collapse-horizontal") ? "width" : "height"
|
|
}
|
|
_initializeChildren() {
|
|
if (!this._config.parent)
|
|
return;
|
|
const t = this._getFirstLevelChildren(ht);
|
|
for (const e of t) {
|
|
const t = z.getElementFromSelector(e);
|
|
t && this._addAriaAndCollapsedClass([e], this._isShown(t))
|
|
}
|
|
}
|
|
_getFirstLevelChildren(t) {
|
|
const e = z.find(":scope .collapse .collapse", this._config.parent);
|
|
return z.find(t, this._config.parent).filter((t => !e.includes(t)))
|
|
}
|
|
_addAriaAndCollapsedClass(t, e) {
|
|
if (t.length)
|
|
for (const i of t)
|
|
i.classList.toggle("collapsed", !e),
|
|
i.setAttribute("aria-expanded", e)
|
|
}
|
|
static jQueryInterface(t) {
|
|
const e = {};
|
|
return "string" == typeof t && /show|hide/.test(t) && (e.toggle = !1),
|
|
this.each((function() {
|
|
const i = ft.getOrCreateInstance(this, e);
|
|
if ("string" == typeof t) {
|
|
if (void 0 === i[t])
|
|
throw new TypeError(`No method named "${t}"`);
|
|
i[t]()
|
|
}
|
|
}
|
|
))
|
|
}
|
|
}
|
|
I.on(document, "click.bs.collapse.data-api", ht, (function(t) {
|
|
("A" === t.target.tagName || t.delegateTarget && "A" === t.delegateTarget.tagName) && t.preventDefault();
|
|
for (const t of z.getMultipleElementsFromSelector(this))
|
|
ft.getOrCreateInstance(t, {
|
|
toggle: !1
|
|
}).toggle()
|
|
}
|
|
)),
|
|
f(ft);
|
|
var pt = "top"
|
|
, mt = "bottom"
|
|
, gt = "right"
|
|
, _t = "left"
|
|
, bt = "auto"
|
|
, vt = [pt, mt, gt, _t]
|
|
, yt = "start"
|
|
, wt = "end"
|
|
, At = "clippingParents"
|
|
, Et = "viewport"
|
|
, Tt = "popper"
|
|
, Ct = "reference"
|
|
, Ot = vt.reduce((function(t, e) {
|
|
return t.concat([e + "-" + yt, e + "-" + wt])
|
|
}
|
|
), [])
|
|
, xt = [].concat(vt, [bt]).reduce((function(t, e) {
|
|
return t.concat([e, e + "-" + yt, e + "-" + wt])
|
|
}
|
|
), [])
|
|
, kt = "beforeRead"
|
|
, Lt = "read"
|
|
, St = "afterRead"
|
|
, Dt = "beforeMain"
|
|
, It = "main"
|
|
, Nt = "afterMain"
|
|
, Pt = "beforeWrite"
|
|
, jt = "write"
|
|
, Mt = "afterWrite"
|
|
, Ft = [kt, Lt, St, Dt, It, Nt, Pt, jt, Mt];
|
|
function Ht(t) {
|
|
return t ? (t.nodeName || "").toLowerCase() : null
|
|
}
|
|
function $t(t) {
|
|
if (null == t)
|
|
return window;
|
|
if ("[object Window]" !== t.toString()) {
|
|
var e = t.ownerDocument;
|
|
return e && e.defaultView || window
|
|
}
|
|
return t
|
|
}
|
|
function Wt(t) {
|
|
return t instanceof $t(t).Element || t instanceof Element
|
|
}
|
|
function Bt(t) {
|
|
return t instanceof $t(t).HTMLElement || t instanceof HTMLElement
|
|
}
|
|
function zt(t) {
|
|
return "undefined" != typeof ShadowRoot && (t instanceof $t(t).ShadowRoot || t instanceof ShadowRoot)
|
|
}
|
|
const Rt = {
|
|
name: "applyStyles",
|
|
enabled: !0,
|
|
phase: "write",
|
|
fn: function(t) {
|
|
var e = t.state;
|
|
Object.keys(e.elements).forEach((function(t) {
|
|
var i = e.styles[t] || {}
|
|
, n = e.attributes[t] || {}
|
|
, s = e.elements[t];
|
|
Bt(s) && Ht(s) && (Object.assign(s.style, i),
|
|
Object.keys(n).forEach((function(t) {
|
|
var e = n[t];
|
|
!1 === e ? s.removeAttribute(t) : s.setAttribute(t, !0 === e ? "" : e)
|
|
}
|
|
)))
|
|
}
|
|
))
|
|
},
|
|
effect: function(t) {
|
|
var e = t.state
|
|
, i = {
|
|
popper: {
|
|
position: e.options.strategy,
|
|
left: "0",
|
|
top: "0",
|
|
margin: "0"
|
|
},
|
|
arrow: {
|
|
position: "absolute"
|
|
},
|
|
reference: {}
|
|
};
|
|
return Object.assign(e.elements.popper.style, i.popper),
|
|
e.styles = i,
|
|
e.elements.arrow && Object.assign(e.elements.arrow.style, i.arrow),
|
|
function() {
|
|
Object.keys(e.elements).forEach((function(t) {
|
|
var n = e.elements[t]
|
|
, s = e.attributes[t] || {}
|
|
, o = Object.keys(e.styles.hasOwnProperty(t) ? e.styles[t] : i[t]).reduce((function(t, e) {
|
|
return t[e] = "",
|
|
t
|
|
}
|
|
), {});
|
|
Bt(n) && Ht(n) && (Object.assign(n.style, o),
|
|
Object.keys(s).forEach((function(t) {
|
|
n.removeAttribute(t)
|
|
}
|
|
)))
|
|
}
|
|
))
|
|
}
|
|
},
|
|
requires: ["computeStyles"]
|
|
};
|
|
function qt(t) {
|
|
return t.split("-")[0]
|
|
}
|
|
var Vt = Math.max
|
|
, Kt = Math.min
|
|
, Qt = Math.round;
|
|
function Xt() {
|
|
var t = navigator.userAgentData;
|
|
return null != t && t.brands ? t.brands.map((function(t) {
|
|
return t.brand + "/" + t.version
|
|
}
|
|
)).join(" ") : navigator.userAgent
|
|
}
|
|
function Yt() {
|
|
return !/^((?!chrome|android).)*safari/i.test(Xt())
|
|
}
|
|
function Ut(t, e, i) {
|
|
void 0 === e && (e = !1),
|
|
void 0 === i && (i = !1);
|
|
var n = t.getBoundingClientRect()
|
|
, s = 1
|
|
, o = 1;
|
|
e && Bt(t) && (s = t.offsetWidth > 0 && Qt(n.width) / t.offsetWidth || 1,
|
|
o = t.offsetHeight > 0 && Qt(n.height) / t.offsetHeight || 1);
|
|
var r = (Wt(t) ? $t(t) : window).visualViewport
|
|
, a = !Yt() && i
|
|
, l = (n.left + (a && r ? r.offsetLeft : 0)) / s
|
|
, c = (n.top + (a && r ? r.offsetTop : 0)) / o
|
|
, h = n.width / s
|
|
, d = n.height / o;
|
|
return {
|
|
width: h,
|
|
height: d,
|
|
top: c,
|
|
right: l + h,
|
|
bottom: c + d,
|
|
left: l,
|
|
x: l,
|
|
y: c
|
|
}
|
|
}
|
|
function Gt(t) {
|
|
var e = Ut(t)
|
|
, i = t.offsetWidth
|
|
, n = t.offsetHeight;
|
|
return Math.abs(e.width - i) <= 1 && (i = e.width),
|
|
Math.abs(e.height - n) <= 1 && (n = e.height),
|
|
{
|
|
x: t.offsetLeft,
|
|
y: t.offsetTop,
|
|
width: i,
|
|
height: n
|
|
}
|
|
}
|
|
function Jt(t, e) {
|
|
var i = e.getRootNode && e.getRootNode();
|
|
if (t.contains(e))
|
|
return !0;
|
|
if (i && zt(i)) {
|
|
var n = e;
|
|
do {
|
|
if (n && t.isSameNode(n))
|
|
return !0;
|
|
n = n.parentNode || n.host
|
|
} while (n)
|
|
}
|
|
return !1
|
|
}
|
|
function Zt(t) {
|
|
return $t(t).getComputedStyle(t)
|
|
}
|
|
function te(t) {
|
|
return ["table", "td", "th"].indexOf(Ht(t)) >= 0
|
|
}
|
|
function ee(t) {
|
|
return ((Wt(t) ? t.ownerDocument : t.document) || window.document).documentElement
|
|
}
|
|
function ie(t) {
|
|
return "html" === Ht(t) ? t : t.assignedSlot || t.parentNode || (zt(t) ? t.host : null) || ee(t)
|
|
}
|
|
function ne(t) {
|
|
return Bt(t) && "fixed" !== Zt(t).position ? t.offsetParent : null
|
|
}
|
|
function se(t) {
|
|
for (var e = $t(t), i = ne(t); i && te(i) && "static" === Zt(i).position; )
|
|
i = ne(i);
|
|
return i && ("html" === Ht(i) || "body" === Ht(i) && "static" === Zt(i).position) ? e : i || function(t) {
|
|
var e = /firefox/i.test(Xt());
|
|
if (/Trident/i.test(Xt()) && Bt(t) && "fixed" === Zt(t).position)
|
|
return null;
|
|
var i = ie(t);
|
|
for (zt(i) && (i = i.host); Bt(i) && ["html", "body"].indexOf(Ht(i)) < 0; ) {
|
|
var n = Zt(i);
|
|
if ("none" !== n.transform || "none" !== n.perspective || "paint" === n.contain || -1 !== ["transform", "perspective"].indexOf(n.willChange) || e && "filter" === n.willChange || e && n.filter && "none" !== n.filter)
|
|
return i;
|
|
i = i.parentNode
|
|
}
|
|
return null
|
|
}(t) || e
|
|
}
|
|
function oe(t) {
|
|
return ["top", "bottom"].indexOf(t) >= 0 ? "x" : "y"
|
|
}
|
|
function re(t, e, i) {
|
|
return Vt(t, Kt(e, i))
|
|
}
|
|
function ae(t) {
|
|
return Object.assign({}, {
|
|
top: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
left: 0
|
|
}, t)
|
|
}
|
|
function le(t, e) {
|
|
return e.reduce((function(e, i) {
|
|
return e[i] = t,
|
|
e
|
|
}
|
|
), {})
|
|
}
|
|
const ce = {
|
|
name: "arrow",
|
|
enabled: !0,
|
|
phase: "main",
|
|
fn: function(t) {
|
|
var e, i = t.state, n = t.name, s = t.options, o = i.elements.arrow, r = i.modifiersData.popperOffsets, a = qt(i.placement), l = oe(a), c = [_t, gt].indexOf(a) >= 0 ? "height" : "width";
|
|
if (o && r) {
|
|
var h = function(t, e) {
|
|
return ae("number" != typeof (t = "function" == typeof t ? t(Object.assign({}, e.rects, {
|
|
placement: e.placement
|
|
})) : t) ? t : le(t, vt))
|
|
}(s.padding, i)
|
|
, d = Gt(o)
|
|
, u = "y" === l ? pt : _t
|
|
, f = "y" === l ? mt : gt
|
|
, p = i.rects.reference[c] + i.rects.reference[l] - r[l] - i.rects.popper[c]
|
|
, m = r[l] - i.rects.reference[l]
|
|
, g = se(o)
|
|
, _ = g ? "y" === l ? g.clientHeight || 0 : g.clientWidth || 0 : 0
|
|
, b = p / 2 - m / 2
|
|
, v = h[u]
|
|
, y = _ - d[c] - h[f]
|
|
, w = _ / 2 - d[c] / 2 + b
|
|
, A = re(v, w, y)
|
|
, E = l;
|
|
i.modifiersData[n] = ((e = {})[E] = A,
|
|
e.centerOffset = A - w,
|
|
e)
|
|
}
|
|
},
|
|
effect: function(t) {
|
|
var e = t.state
|
|
, i = t.options.element
|
|
, n = void 0 === i ? "[data-popper-arrow]" : i;
|
|
null != n && ("string" != typeof n || (n = e.elements.popper.querySelector(n))) && Jt(e.elements.popper, n) && (e.elements.arrow = n)
|
|
},
|
|
requires: ["popperOffsets"],
|
|
requiresIfExists: ["preventOverflow"]
|
|
};
|
|
function he(t) {
|
|
return t.split("-")[1]
|
|
}
|
|
var de = {
|
|
top: "auto",
|
|
right: "auto",
|
|
bottom: "auto",
|
|
left: "auto"
|
|
};
|
|
function ue(t) {
|
|
var e, i = t.popper, n = t.popperRect, s = t.placement, o = t.variation, r = t.offsets, a = t.position, l = t.gpuAcceleration, c = t.adaptive, h = t.roundOffsets, d = t.isFixed, u = r.x, f = void 0 === u ? 0 : u, p = r.y, m = void 0 === p ? 0 : p, g = "function" == typeof h ? h({
|
|
x: f,
|
|
y: m
|
|
}) : {
|
|
x: f,
|
|
y: m
|
|
};
|
|
f = g.x,
|
|
m = g.y;
|
|
var _ = r.hasOwnProperty("x")
|
|
, b = r.hasOwnProperty("y")
|
|
, v = _t
|
|
, y = pt
|
|
, w = window;
|
|
if (c) {
|
|
var A = se(i)
|
|
, E = "clientHeight"
|
|
, T = "clientWidth";
|
|
A === $t(i) && "static" !== Zt(A = ee(i)).position && "absolute" === a && (E = "scrollHeight",
|
|
T = "scrollWidth"),
|
|
(s === pt || (s === _t || s === gt) && o === wt) && (y = mt,
|
|
m -= (d && A === w && w.visualViewport ? w.visualViewport.height : A[E]) - n.height,
|
|
m *= l ? 1 : -1),
|
|
s !== _t && (s !== pt && s !== mt || o !== wt) || (v = gt,
|
|
f -= (d && A === w && w.visualViewport ? w.visualViewport.width : A[T]) - n.width,
|
|
f *= l ? 1 : -1)
|
|
}
|
|
var C, O = Object.assign({
|
|
position: a
|
|
}, c && de), x = !0 === h ? function(t) {
|
|
var e = t.x
|
|
, i = t.y
|
|
, n = window.devicePixelRatio || 1;
|
|
return {
|
|
x: Qt(e * n) / n || 0,
|
|
y: Qt(i * n) / n || 0
|
|
}
|
|
}({
|
|
x: f,
|
|
y: m
|
|
}) : {
|
|
x: f,
|
|
y: m
|
|
};
|
|
return f = x.x,
|
|
m = x.y,
|
|
l ? Object.assign({}, O, ((C = {})[y] = b ? "0" : "",
|
|
C[v] = _ ? "0" : "",
|
|
C.transform = (w.devicePixelRatio || 1) <= 1 ? "translate(" + f + "px, " + m + "px)" : "translate3d(" + f + "px, " + m + "px, 0)",
|
|
C)) : Object.assign({}, O, ((e = {})[y] = b ? m + "px" : "",
|
|
e[v] = _ ? f + "px" : "",
|
|
e.transform = "",
|
|
e))
|
|
}
|
|
const fe = {
|
|
name: "computeStyles",
|
|
enabled: !0,
|
|
phase: "beforeWrite",
|
|
fn: function(t) {
|
|
var e = t.state
|
|
, i = t.options
|
|
, n = i.gpuAcceleration
|
|
, s = void 0 === n || n
|
|
, o = i.adaptive
|
|
, r = void 0 === o || o
|
|
, a = i.roundOffsets
|
|
, l = void 0 === a || a
|
|
, c = {
|
|
placement: qt(e.placement),
|
|
variation: he(e.placement),
|
|
popper: e.elements.popper,
|
|
popperRect: e.rects.popper,
|
|
gpuAcceleration: s,
|
|
isFixed: "fixed" === e.options.strategy
|
|
};
|
|
null != e.modifiersData.popperOffsets && (e.styles.popper = Object.assign({}, e.styles.popper, ue(Object.assign({}, c, {
|
|
offsets: e.modifiersData.popperOffsets,
|
|
position: e.options.strategy,
|
|
adaptive: r,
|
|
roundOffsets: l
|
|
})))),
|
|
null != e.modifiersData.arrow && (e.styles.arrow = Object.assign({}, e.styles.arrow, ue(Object.assign({}, c, {
|
|
offsets: e.modifiersData.arrow,
|
|
position: "absolute",
|
|
adaptive: !1,
|
|
roundOffsets: l
|
|
})))),
|
|
e.attributes.popper = Object.assign({}, e.attributes.popper, {
|
|
"data-popper-placement": e.placement
|
|
})
|
|
},
|
|
data: {}
|
|
};
|
|
var pe = {
|
|
passive: !0
|
|
};
|
|
const me = {
|
|
name: "eventListeners",
|
|
enabled: !0,
|
|
phase: "write",
|
|
fn: function() {},
|
|
effect: function(t) {
|
|
var e = t.state
|
|
, i = t.instance
|
|
, n = t.options
|
|
, s = n.scroll
|
|
, o = void 0 === s || s
|
|
, r = n.resize
|
|
, a = void 0 === r || r
|
|
, l = $t(e.elements.popper)
|
|
, c = [].concat(e.scrollParents.reference, e.scrollParents.popper);
|
|
return o && c.forEach((function(t) {
|
|
t.addEventListener("scroll", i.update, pe)
|
|
}
|
|
)),
|
|
a && l.addEventListener("resize", i.update, pe),
|
|
function() {
|
|
o && c.forEach((function(t) {
|
|
t.removeEventListener("scroll", i.update, pe)
|
|
}
|
|
)),
|
|
a && l.removeEventListener("resize", i.update, pe)
|
|
}
|
|
},
|
|
data: {}
|
|
};
|
|
var ge = {
|
|
left: "right",
|
|
right: "left",
|
|
bottom: "top",
|
|
top: "bottom"
|
|
};
|
|
function _e(t) {
|
|
return t.replace(/left|right|bottom|top/g, (function(t) {
|
|
return ge[t]
|
|
}
|
|
))
|
|
}
|
|
var be = {
|
|
start: "end",
|
|
end: "start"
|
|
};
|
|
function ve(t) {
|
|
return t.replace(/start|end/g, (function(t) {
|
|
return be[t]
|
|
}
|
|
))
|
|
}
|
|
function ye(t) {
|
|
var e = $t(t);
|
|
return {
|
|
scrollLeft: e.pageXOffset,
|
|
scrollTop: e.pageYOffset
|
|
}
|
|
}
|
|
function we(t) {
|
|
return Ut(ee(t)).left + ye(t).scrollLeft
|
|
}
|
|
function Ae(t) {
|
|
var e = Zt(t)
|
|
, i = e.overflow
|
|
, n = e.overflowX
|
|
, s = e.overflowY;
|
|
return /auto|scroll|overlay|hidden/.test(i + s + n)
|
|
}
|
|
function Ee(t) {
|
|
return ["html", "body", "#document"].indexOf(Ht(t)) >= 0 ? t.ownerDocument.body : Bt(t) && Ae(t) ? t : Ee(ie(t))
|
|
}
|
|
function Te(t, e) {
|
|
var i;
|
|
void 0 === e && (e = []);
|
|
var n = Ee(t)
|
|
, s = n === (null == (i = t.ownerDocument) ? void 0 : i.body)
|
|
, o = $t(n)
|
|
, r = s ? [o].concat(o.visualViewport || [], Ae(n) ? n : []) : n
|
|
, a = e.concat(r);
|
|
return s ? a : a.concat(Te(ie(r)))
|
|
}
|
|
function Ce(t) {
|
|
return Object.assign({}, t, {
|
|
left: t.x,
|
|
top: t.y,
|
|
right: t.x + t.width,
|
|
bottom: t.y + t.height
|
|
})
|
|
}
|
|
function Oe(t, e, i) {
|
|
return e === Et ? Ce(function(t, e) {
|
|
var i = $t(t)
|
|
, n = ee(t)
|
|
, s = i.visualViewport
|
|
, o = n.clientWidth
|
|
, r = n.clientHeight
|
|
, a = 0
|
|
, l = 0;
|
|
if (s) {
|
|
o = s.width,
|
|
r = s.height;
|
|
var c = Yt();
|
|
(c || !c && "fixed" === e) && (a = s.offsetLeft,
|
|
l = s.offsetTop)
|
|
}
|
|
return {
|
|
width: o,
|
|
height: r,
|
|
x: a + we(t),
|
|
y: l
|
|
}
|
|
}(t, i)) : Wt(e) ? function(t, e) {
|
|
var i = Ut(t, !1, "fixed" === e);
|
|
return i.top = i.top + t.clientTop,
|
|
i.left = i.left + t.clientLeft,
|
|
i.bottom = i.top + t.clientHeight,
|
|
i.right = i.left + t.clientWidth,
|
|
i.width = t.clientWidth,
|
|
i.height = t.clientHeight,
|
|
i.x = i.left,
|
|
i.y = i.top,
|
|
i
|
|
}(e, i) : Ce(function(t) {
|
|
var e, i = ee(t), n = ye(t), s = null == (e = t.ownerDocument) ? void 0 : e.body, o = Vt(i.scrollWidth, i.clientWidth, s ? s.scrollWidth : 0, s ? s.clientWidth : 0), r = Vt(i.scrollHeight, i.clientHeight, s ? s.scrollHeight : 0, s ? s.clientHeight : 0), a = -n.scrollLeft + we(t), l = -n.scrollTop;
|
|
return "rtl" === Zt(s || i).direction && (a += Vt(i.clientWidth, s ? s.clientWidth : 0) - o),
|
|
{
|
|
width: o,
|
|
height: r,
|
|
x: a,
|
|
y: l
|
|
}
|
|
}(ee(t)))
|
|
}
|
|
function xe(t) {
|
|
var e, i = t.reference, n = t.element, s = t.placement, o = s ? qt(s) : null, r = s ? he(s) : null, a = i.x + i.width / 2 - n.width / 2, l = i.y + i.height / 2 - n.height / 2;
|
|
switch (o) {
|
|
case pt:
|
|
e = {
|
|
x: a,
|
|
y: i.y - n.height
|
|
};
|
|
break;
|
|
case mt:
|
|
e = {
|
|
x: a,
|
|
y: i.y + i.height
|
|
};
|
|
break;
|
|
case gt:
|
|
e = {
|
|
x: i.x + i.width,
|
|
y: l
|
|
};
|
|
break;
|
|
case _t:
|
|
e = {
|
|
x: i.x - n.width,
|
|
y: l
|
|
};
|
|
break;
|
|
default:
|
|
e = {
|
|
x: i.x,
|
|
y: i.y
|
|
}
|
|
}
|
|
var c = o ? oe(o) : null;
|
|
if (null != c) {
|
|
var h = "y" === c ? "height" : "width";
|
|
switch (r) {
|
|
case yt:
|
|
e[c] = e[c] - (i[h] / 2 - n[h] / 2);
|
|
break;
|
|
case wt:
|
|
e[c] = e[c] + (i[h] / 2 - n[h] / 2)
|
|
}
|
|
}
|
|
return e
|
|
}
|
|
function ke(t, e) {
|
|
void 0 === e && (e = {});
|
|
var i = e
|
|
, n = i.placement
|
|
, s = void 0 === n ? t.placement : n
|
|
, o = i.strategy
|
|
, r = void 0 === o ? t.strategy : o
|
|
, a = i.boundary
|
|
, l = void 0 === a ? At : a
|
|
, c = i.rootBoundary
|
|
, h = void 0 === c ? Et : c
|
|
, d = i.elementContext
|
|
, u = void 0 === d ? Tt : d
|
|
, f = i.altBoundary
|
|
, p = void 0 !== f && f
|
|
, m = i.padding
|
|
, g = void 0 === m ? 0 : m
|
|
, _ = ae("number" != typeof g ? g : le(g, vt))
|
|
, b = u === Tt ? Ct : Tt
|
|
, v = t.rects.popper
|
|
, y = t.elements[p ? b : u]
|
|
, w = function(t, e, i, n) {
|
|
var s = "clippingParents" === e ? function(t) {
|
|
var e = Te(ie(t))
|
|
, i = ["absolute", "fixed"].indexOf(Zt(t).position) >= 0 && Bt(t) ? se(t) : t;
|
|
return Wt(i) ? e.filter((function(t) {
|
|
return Wt(t) && Jt(t, i) && "body" !== Ht(t)
|
|
}
|
|
)) : []
|
|
}(t) : [].concat(e)
|
|
, o = [].concat(s, [i])
|
|
, r = o[0]
|
|
, a = o.reduce((function(e, i) {
|
|
var s = Oe(t, i, n);
|
|
return e.top = Vt(s.top, e.top),
|
|
e.right = Kt(s.right, e.right),
|
|
e.bottom = Kt(s.bottom, e.bottom),
|
|
e.left = Vt(s.left, e.left),
|
|
e
|
|
}
|
|
), Oe(t, r, n));
|
|
return a.width = a.right - a.left,
|
|
a.height = a.bottom - a.top,
|
|
a.x = a.left,
|
|
a.y = a.top,
|
|
a
|
|
}(Wt(y) ? y : y.contextElement || ee(t.elements.popper), l, h, r)
|
|
, A = Ut(t.elements.reference)
|
|
, E = xe({
|
|
reference: A,
|
|
element: v,
|
|
strategy: "absolute",
|
|
placement: s
|
|
})
|
|
, T = Ce(Object.assign({}, v, E))
|
|
, C = u === Tt ? T : A
|
|
, O = {
|
|
top: w.top - C.top + _.top,
|
|
bottom: C.bottom - w.bottom + _.bottom,
|
|
left: w.left - C.left + _.left,
|
|
right: C.right - w.right + _.right
|
|
}
|
|
, x = t.modifiersData.offset;
|
|
if (u === Tt && x) {
|
|
var k = x[s];
|
|
Object.keys(O).forEach((function(t) {
|
|
var e = [gt, mt].indexOf(t) >= 0 ? 1 : -1
|
|
, i = [pt, mt].indexOf(t) >= 0 ? "y" : "x";
|
|
O[t] += k[i] * e
|
|
}
|
|
))
|
|
}
|
|
return O
|
|
}
|
|
function Le(t, e) {
|
|
void 0 === e && (e = {});
|
|
var i = e
|
|
, n = i.placement
|
|
, s = i.boundary
|
|
, o = i.rootBoundary
|
|
, r = i.padding
|
|
, a = i.flipVariations
|
|
, l = i.allowedAutoPlacements
|
|
, c = void 0 === l ? xt : l
|
|
, h = he(n)
|
|
, d = h ? a ? Ot : Ot.filter((function(t) {
|
|
return he(t) === h
|
|
}
|
|
)) : vt
|
|
, u = d.filter((function(t) {
|
|
return c.indexOf(t) >= 0
|
|
}
|
|
));
|
|
0 === u.length && (u = d);
|
|
var f = u.reduce((function(e, i) {
|
|
return e[i] = ke(t, {
|
|
placement: i,
|
|
boundary: s,
|
|
rootBoundary: o,
|
|
padding: r
|
|
})[qt(i)],
|
|
e
|
|
}
|
|
), {});
|
|
return Object.keys(f).sort((function(t, e) {
|
|
return f[t] - f[e]
|
|
}
|
|
))
|
|
}
|
|
const Se = {
|
|
name: "flip",
|
|
enabled: !0,
|
|
phase: "main",
|
|
fn: function(t) {
|
|
var e = t.state
|
|
, i = t.options
|
|
, n = t.name;
|
|
if (!e.modifiersData[n]._skip) {
|
|
for (var s = i.mainAxis, o = void 0 === s || s, r = i.altAxis, a = void 0 === r || r, l = i.fallbackPlacements, c = i.padding, h = i.boundary, d = i.rootBoundary, u = i.altBoundary, f = i.flipVariations, p = void 0 === f || f, m = i.allowedAutoPlacements, g = e.options.placement, _ = qt(g), b = l || (_ !== g && p ? function(t) {
|
|
if (qt(t) === bt)
|
|
return [];
|
|
var e = _e(t);
|
|
return [ve(t), e, ve(e)]
|
|
}(g) : [_e(g)]), v = [g].concat(b).reduce((function(t, i) {
|
|
return t.concat(qt(i) === bt ? Le(e, {
|
|
placement: i,
|
|
boundary: h,
|
|
rootBoundary: d,
|
|
padding: c,
|
|
flipVariations: p,
|
|
allowedAutoPlacements: m
|
|
}) : i)
|
|
}
|
|
), []), y = e.rects.reference, w = e.rects.popper, A = new Map, E = !0, T = v[0], C = 0; C < v.length; C++) {
|
|
var O = v[C]
|
|
, x = qt(O)
|
|
, k = he(O) === yt
|
|
, L = [pt, mt].indexOf(x) >= 0
|
|
, S = L ? "width" : "height"
|
|
, D = ke(e, {
|
|
placement: O,
|
|
boundary: h,
|
|
rootBoundary: d,
|
|
altBoundary: u,
|
|
padding: c
|
|
})
|
|
, I = L ? k ? gt : _t : k ? mt : pt;
|
|
y[S] > w[S] && (I = _e(I));
|
|
var N = _e(I)
|
|
, P = [];
|
|
if (o && P.push(D[x] <= 0),
|
|
a && P.push(D[I] <= 0, D[N] <= 0),
|
|
P.every((function(t) {
|
|
return t
|
|
}
|
|
))) {
|
|
T = O,
|
|
E = !1;
|
|
break
|
|
}
|
|
A.set(O, P)
|
|
}
|
|
if (E)
|
|
for (var j = function(t) {
|
|
var e = v.find((function(e) {
|
|
var i = A.get(e);
|
|
if (i)
|
|
return i.slice(0, t).every((function(t) {
|
|
return t
|
|
}
|
|
))
|
|
}
|
|
));
|
|
if (e)
|
|
return T = e,
|
|
"break"
|
|
}, M = p ? 3 : 1; M > 0 && "break" !== j(M); M--)
|
|
;
|
|
e.placement !== T && (e.modifiersData[n]._skip = !0,
|
|
e.placement = T,
|
|
e.reset = !0)
|
|
}
|
|
},
|
|
requiresIfExists: ["offset"],
|
|
data: {
|
|
_skip: !1
|
|
}
|
|
};
|
|
function De(t, e, i) {
|
|
return void 0 === i && (i = {
|
|
x: 0,
|
|
y: 0
|
|
}),
|
|
{
|
|
top: t.top - e.height - i.y,
|
|
right: t.right - e.width + i.x,
|
|
bottom: t.bottom - e.height + i.y,
|
|
left: t.left - e.width - i.x
|
|
}
|
|
}
|
|
function Ie(t) {
|
|
return [pt, gt, mt, _t].some((function(e) {
|
|
return t[e] >= 0
|
|
}
|
|
))
|
|
}
|
|
const Ne = {
|
|
name: "hide",
|
|
enabled: !0,
|
|
phase: "main",
|
|
requiresIfExists: ["preventOverflow"],
|
|
fn: function(t) {
|
|
var e = t.state
|
|
, i = t.name
|
|
, n = e.rects.reference
|
|
, s = e.rects.popper
|
|
, o = e.modifiersData.preventOverflow
|
|
, r = ke(e, {
|
|
elementContext: "reference"
|
|
})
|
|
, a = ke(e, {
|
|
altBoundary: !0
|
|
})
|
|
, l = De(r, n)
|
|
, c = De(a, s, o)
|
|
, h = Ie(l)
|
|
, d = Ie(c);
|
|
e.modifiersData[i] = {
|
|
referenceClippingOffsets: l,
|
|
popperEscapeOffsets: c,
|
|
isReferenceHidden: h,
|
|
hasPopperEscaped: d
|
|
},
|
|
e.attributes.popper = Object.assign({}, e.attributes.popper, {
|
|
"data-popper-reference-hidden": h,
|
|
"data-popper-escaped": d
|
|
})
|
|
}
|
|
}
|
|
, Pe = {
|
|
name: "offset",
|
|
enabled: !0,
|
|
phase: "main",
|
|
requires: ["popperOffsets"],
|
|
fn: function(t) {
|
|
var e = t.state
|
|
, i = t.options
|
|
, n = t.name
|
|
, s = i.offset
|
|
, o = void 0 === s ? [0, 0] : s
|
|
, r = xt.reduce((function(t, i) {
|
|
return t[i] = function(t, e, i) {
|
|
var n = qt(t)
|
|
, s = [_t, pt].indexOf(n) >= 0 ? -1 : 1
|
|
, o = "function" == typeof i ? i(Object.assign({}, e, {
|
|
placement: t
|
|
})) : i
|
|
, r = o[0]
|
|
, a = o[1];
|
|
return r = r || 0,
|
|
a = (a || 0) * s,
|
|
[_t, gt].indexOf(n) >= 0 ? {
|
|
x: a,
|
|
y: r
|
|
} : {
|
|
x: r,
|
|
y: a
|
|
}
|
|
}(i, e.rects, o),
|
|
t
|
|
}
|
|
), {})
|
|
, a = r[e.placement]
|
|
, l = a.x
|
|
, c = a.y;
|
|
null != e.modifiersData.popperOffsets && (e.modifiersData.popperOffsets.x += l,
|
|
e.modifiersData.popperOffsets.y += c),
|
|
e.modifiersData[n] = r
|
|
}
|
|
}
|
|
, je = {
|
|
name: "popperOffsets",
|
|
enabled: !0,
|
|
phase: "read",
|
|
fn: function(t) {
|
|
var e = t.state
|
|
, i = t.name;
|
|
e.modifiersData[i] = xe({
|
|
reference: e.rects.reference,
|
|
element: e.rects.popper,
|
|
strategy: "absolute",
|
|
placement: e.placement
|
|
})
|
|
},
|
|
data: {}
|
|
}
|
|
, Me = {
|
|
name: "preventOverflow",
|
|
enabled: !0,
|
|
phase: "main",
|
|
fn: function(t) {
|
|
var e = t.state
|
|
, i = t.options
|
|
, n = t.name
|
|
, s = i.mainAxis
|
|
, o = void 0 === s || s
|
|
, r = i.altAxis
|
|
, a = void 0 !== r && r
|
|
, l = i.boundary
|
|
, c = i.rootBoundary
|
|
, h = i.altBoundary
|
|
, d = i.padding
|
|
, u = i.tether
|
|
, f = void 0 === u || u
|
|
, p = i.tetherOffset
|
|
, m = void 0 === p ? 0 : p
|
|
, g = ke(e, {
|
|
boundary: l,
|
|
rootBoundary: c,
|
|
padding: d,
|
|
altBoundary: h
|
|
})
|
|
, _ = qt(e.placement)
|
|
, b = he(e.placement)
|
|
, v = !b
|
|
, y = oe(_)
|
|
, w = "x" === y ? "y" : "x"
|
|
, A = e.modifiersData.popperOffsets
|
|
, E = e.rects.reference
|
|
, T = e.rects.popper
|
|
, C = "function" == typeof m ? m(Object.assign({}, e.rects, {
|
|
placement: e.placement
|
|
})) : m
|
|
, O = "number" == typeof C ? {
|
|
mainAxis: C,
|
|
altAxis: C
|
|
} : Object.assign({
|
|
mainAxis: 0,
|
|
altAxis: 0
|
|
}, C)
|
|
, x = e.modifiersData.offset ? e.modifiersData.offset[e.placement] : null
|
|
, k = {
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
if (A) {
|
|
if (o) {
|
|
var L, S = "y" === y ? pt : _t, D = "y" === y ? mt : gt, I = "y" === y ? "height" : "width", N = A[y], P = N + g[S], j = N - g[D], M = f ? -T[I] / 2 : 0, F = b === yt ? E[I] : T[I], H = b === yt ? -T[I] : -E[I], $ = e.elements.arrow, W = f && $ ? Gt($) : {
|
|
width: 0,
|
|
height: 0
|
|
}, B = e.modifiersData["arrow#persistent"] ? e.modifiersData["arrow#persistent"].padding : {
|
|
top: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
left: 0
|
|
}, z = B[S], R = B[D], q = re(0, E[I], W[I]), V = v ? E[I] / 2 - M - q - z - O.mainAxis : F - q - z - O.mainAxis, K = v ? -E[I] / 2 + M + q + R + O.mainAxis : H + q + R + O.mainAxis, Q = e.elements.arrow && se(e.elements.arrow), X = Q ? "y" === y ? Q.clientTop || 0 : Q.clientLeft || 0 : 0, Y = null != (L = null == x ? void 0 : x[y]) ? L : 0, U = N + K - Y, G = re(f ? Kt(P, N + V - Y - X) : P, N, f ? Vt(j, U) : j);
|
|
A[y] = G,
|
|
k[y] = G - N
|
|
}
|
|
if (a) {
|
|
var J, Z = "x" === y ? pt : _t, tt = "x" === y ? mt : gt, et = A[w], it = "y" === w ? "height" : "width", nt = et + g[Z], st = et - g[tt], ot = -1 !== [pt, _t].indexOf(_), rt = null != (J = null == x ? void 0 : x[w]) ? J : 0, at = ot ? nt : et - E[it] - T[it] - rt + O.altAxis, lt = ot ? et + E[it] + T[it] - rt - O.altAxis : st, ct = f && ot ? function(t, e, i) {
|
|
var n = re(t, e, i);
|
|
return n > i ? i : n
|
|
}(at, et, lt) : re(f ? at : nt, et, f ? lt : st);
|
|
A[w] = ct,
|
|
k[w] = ct - et
|
|
}
|
|
e.modifiersData[n] = k
|
|
}
|
|
},
|
|
requiresIfExists: ["offset"]
|
|
};
|
|
function Fe(t, e, i) {
|
|
void 0 === i && (i = !1);
|
|
var n, s, o = Bt(e), r = Bt(e) && function(t) {
|
|
var e = t.getBoundingClientRect()
|
|
, i = Qt(e.width) / t.offsetWidth || 1
|
|
, n = Qt(e.height) / t.offsetHeight || 1;
|
|
return 1 !== i || 1 !== n
|
|
}(e), a = ee(e), l = Ut(t, r, i), c = {
|
|
scrollLeft: 0,
|
|
scrollTop: 0
|
|
}, h = {
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
return (o || !o && !i) && (("body" !== Ht(e) || Ae(a)) && (c = (n = e) !== $t(n) && Bt(n) ? {
|
|
scrollLeft: (s = n).scrollLeft,
|
|
scrollTop: s.scrollTop
|
|
} : ye(n)),
|
|
Bt(e) ? ((h = Ut(e, !0)).x += e.clientLeft,
|
|
h.y += e.clientTop) : a && (h.x = we(a))),
|
|
{
|
|
x: l.left + c.scrollLeft - h.x,
|
|
y: l.top + c.scrollTop - h.y,
|
|
width: l.width,
|
|
height: l.height
|
|
}
|
|
}
|
|
function He(t) {
|
|
var e = new Map
|
|
, i = new Set
|
|
, n = [];
|
|
function s(t) {
|
|
i.add(t.name),
|
|
[].concat(t.requires || [], t.requiresIfExists || []).forEach((function(t) {
|
|
if (!i.has(t)) {
|
|
var n = e.get(t);
|
|
n && s(n)
|
|
}
|
|
}
|
|
)),
|
|
n.push(t)
|
|
}
|
|
return t.forEach((function(t) {
|
|
e.set(t.name, t)
|
|
}
|
|
)),
|
|
t.forEach((function(t) {
|
|
i.has(t.name) || s(t)
|
|
}
|
|
)),
|
|
n
|
|
}
|
|
var $e = {
|
|
placement: "bottom",
|
|
modifiers: [],
|
|
strategy: "absolute"
|
|
};
|
|
function We() {
|
|
for (var t = arguments.length, e = new Array(t), i = 0; i < t; i++)
|
|
e[i] = arguments[i];
|
|
return !e.some((function(t) {
|
|
return !(t && "function" == typeof t.getBoundingClientRect)
|
|
}
|
|
))
|
|
}
|
|
function Be(t) {
|
|
void 0 === t && (t = {});
|
|
var e = t
|
|
, i = e.defaultModifiers
|
|
, n = void 0 === i ? [] : i
|
|
, s = e.defaultOptions
|
|
, o = void 0 === s ? $e : s;
|
|
return function(t, e, i) {
|
|
void 0 === i && (i = o);
|
|
var s, r, a = {
|
|
placement: "bottom",
|
|
orderedModifiers: [],
|
|
options: Object.assign({}, $e, o),
|
|
modifiersData: {},
|
|
elements: {
|
|
reference: t,
|
|
popper: e
|
|
},
|
|
attributes: {},
|
|
styles: {}
|
|
}, l = [], c = !1, h = {
|
|
state: a,
|
|
setOptions: function(i) {
|
|
var s = "function" == typeof i ? i(a.options) : i;
|
|
d(),
|
|
a.options = Object.assign({}, o, a.options, s),
|
|
a.scrollParents = {
|
|
reference: Wt(t) ? Te(t) : t.contextElement ? Te(t.contextElement) : [],
|
|
popper: Te(e)
|
|
};
|
|
var r, c, u = function(t) {
|
|
var e = He(t);
|
|
return Ft.reduce((function(t, i) {
|
|
return t.concat(e.filter((function(t) {
|
|
return t.phase === i
|
|
}
|
|
)))
|
|
}
|
|
), [])
|
|
}((r = [].concat(n, a.options.modifiers),
|
|
c = r.reduce((function(t, e) {
|
|
var i = t[e.name];
|
|
return t[e.name] = i ? Object.assign({}, i, e, {
|
|
options: Object.assign({}, i.options, e.options),
|
|
data: Object.assign({}, i.data, e.data)
|
|
}) : e,
|
|
t
|
|
}
|
|
), {}),
|
|
Object.keys(c).map((function(t) {
|
|
return c[t]
|
|
}
|
|
))));
|
|
return a.orderedModifiers = u.filter((function(t) {
|
|
return t.enabled
|
|
}
|
|
)),
|
|
a.orderedModifiers.forEach((function(t) {
|
|
var e = t.name
|
|
, i = t.options
|
|
, n = void 0 === i ? {} : i
|
|
, s = t.effect;
|
|
if ("function" == typeof s) {
|
|
var o = s({
|
|
state: a,
|
|
name: e,
|
|
instance: h,
|
|
options: n
|
|
});
|
|
l.push(o || function() {}
|
|
)
|
|
}
|
|
}
|
|
)),
|
|
h.update()
|
|
},
|
|
forceUpdate: function() {
|
|
if (!c) {
|
|
var t = a.elements
|
|
, e = t.reference
|
|
, i = t.popper;
|
|
if (We(e, i)) {
|
|
a.rects = {
|
|
reference: Fe(e, se(i), "fixed" === a.options.strategy),
|
|
popper: Gt(i)
|
|
},
|
|
a.reset = !1,
|
|
a.placement = a.options.placement,
|
|
a.orderedModifiers.forEach((function(t) {
|
|
return a.modifiersData[t.name] = Object.assign({}, t.data)
|
|
}
|
|
));
|
|
for (var n = 0; n < a.orderedModifiers.length; n++)
|
|
if (!0 !== a.reset) {
|
|
var s = a.orderedModifiers[n]
|
|
, o = s.fn
|
|
, r = s.options
|
|
, l = void 0 === r ? {} : r
|
|
, d = s.name;
|
|
"function" == typeof o && (a = o({
|
|
state: a,
|
|
options: l,
|
|
name: d,
|
|
instance: h
|
|
}) || a)
|
|
} else
|
|
a.reset = !1,
|
|
n = -1
|
|
}
|
|
}
|
|
},
|
|
update: (s = function() {
|
|
return new Promise((function(t) {
|
|
h.forceUpdate(),
|
|
t(a)
|
|
}
|
|
))
|
|
}
|
|
,
|
|
function() {
|
|
return r || (r = new Promise((function(t) {
|
|
Promise.resolve().then((function() {
|
|
r = void 0,
|
|
t(s())
|
|
}
|
|
))
|
|
}
|
|
))),
|
|
r
|
|
}
|
|
),
|
|
destroy: function() {
|
|
d(),
|
|
c = !0
|
|
}
|
|
};
|
|
if (!We(t, e))
|
|
return h;
|
|
function d() {
|
|
l.forEach((function(t) {
|
|
return t()
|
|
}
|
|
)),
|
|
l = []
|
|
}
|
|
return h.setOptions(i).then((function(t) {
|
|
!c && i.onFirstUpdate && i.onFirstUpdate(t)
|
|
}
|
|
)),
|
|
h
|
|
}
|
|
}
|
|
var ze = Be()
|
|
, Re = Be({
|
|
defaultModifiers: [me, je, fe, Rt]
|
|
})
|
|
, qe = Be({
|
|
defaultModifiers: [me, je, fe, Rt, Pe, Se, Me, ce, Ne]
|
|
});
|
|
const Ve = Object.freeze(Object.defineProperty({
|
|
__proto__: null,
|
|
popperGenerator: Be,
|
|
detectOverflow: ke,
|
|
createPopperBase: ze,
|
|
createPopper: qe,
|
|
createPopperLite: Re,
|
|
top: pt,
|
|
bottom: mt,
|
|
right: gt,
|
|
left: _t,
|
|
auto: bt,
|
|
basePlacements: vt,
|
|
start: yt,
|
|
end: wt,
|
|
clippingParents: At,
|
|
viewport: Et,
|
|
popper: Tt,
|
|
reference: Ct,
|
|
variationPlacements: Ot,
|
|
placements: xt,
|
|
beforeRead: kt,
|
|
read: Lt,
|
|
afterRead: St,
|
|
beforeMain: Dt,
|
|
main: It,
|
|
afterMain: Nt,
|
|
beforeWrite: Pt,
|
|
write: jt,
|
|
afterWrite: Mt,
|
|
modifierPhases: Ft,
|
|
applyStyles: Rt,
|
|
arrow: ce,
|
|
computeStyles: fe,
|
|
eventListeners: me,
|
|
flip: Se,
|
|
hide: Ne,
|
|
offset: Pe,
|
|
popperOffsets: je,
|
|
preventOverflow: Me
|
|
}, Symbol.toStringTag, {
|
|
value: "Module"
|
|
}))
|
|
, Ke = "dropdown"
|
|
, Qe = "ArrowUp"
|
|
, Xe = "ArrowDown"
|
|
, Ye = "click.bs.dropdown.data-api"
|
|
, Ue = "keydown.bs.dropdown.data-api"
|
|
, Ge = "show"
|
|
, Je = '[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)'
|
|
, Ze = `${Je}.show`
|
|
, ti = ".dropdown-menu"
|
|
, ei = u() ? "top-end" : "top-start"
|
|
, ii = u() ? "top-start" : "top-end"
|
|
, ni = u() ? "bottom-end" : "bottom-start"
|
|
, si = u() ? "bottom-start" : "bottom-end"
|
|
, oi = u() ? "left-start" : "right-start"
|
|
, ri = u() ? "right-start" : "left-start"
|
|
, ai = {
|
|
autoClose: !0,
|
|
boundary: "clippingParents",
|
|
display: "dynamic",
|
|
offset: [0, 2],
|
|
popperConfig: null,
|
|
reference: "toggle"
|
|
}
|
|
, li = {
|
|
autoClose: "(boolean|string)",
|
|
boundary: "(string|element)",
|
|
display: "string",
|
|
offset: "(array|string|function)",
|
|
popperConfig: "(null|object|function)",
|
|
reference: "(string|element|object)"
|
|
};
|
|
class ci extends W {
|
|
constructor(t, e) {
|
|
super(t, e),
|
|
this._popper = null,
|
|
this._parent = this._element.parentNode,
|
|
this._menu = z.next(this._element, ti)[0] || z.prev(this._element, ti)[0] || z.findOne(ti, this._parent),
|
|
this._inNavbar = this._detectNavbar()
|
|
}
|
|
static get Default() {
|
|
return ai
|
|
}
|
|
static get DefaultType() {
|
|
return li
|
|
}
|
|
static get NAME() {
|
|
return Ke
|
|
}
|
|
toggle() {
|
|
return this._isShown() ? this.hide() : this.show()
|
|
}
|
|
show() {
|
|
if (r(this._element) || this._isShown())
|
|
return;
|
|
const t = {
|
|
relatedTarget: this._element
|
|
};
|
|
if (!I.trigger(this._element, "show.bs.dropdown", t).defaultPrevented) {
|
|
if (this._createPopper(),
|
|
"ontouchstart"in document.documentElement && !this._parent.closest(".navbar-nav"))
|
|
for (const t of [].concat(...document.body.children))
|
|
I.on(t, "mouseover", l);
|
|
this._element.focus(),
|
|
this._element.setAttribute("aria-expanded", !0),
|
|
this._menu.classList.add(Ge),
|
|
this._element.classList.add(Ge),
|
|
I.trigger(this._element, "shown.bs.dropdown", t)
|
|
}
|
|
}
|
|
hide() {
|
|
if (r(this._element) || !this._isShown())
|
|
return;
|
|
const t = {
|
|
relatedTarget: this._element
|
|
};
|
|
this._completeHide(t)
|
|
}
|
|
dispose() {
|
|
this._popper && this._popper.destroy(),
|
|
super.dispose()
|
|
}
|
|
update() {
|
|
this._inNavbar = this._detectNavbar(),
|
|
this._popper && this._popper.update()
|
|
}
|
|
_completeHide(t) {
|
|
if (!I.trigger(this._element, "hide.bs.dropdown", t).defaultPrevented) {
|
|
if ("ontouchstart"in document.documentElement)
|
|
for (const t of [].concat(...document.body.children))
|
|
I.off(t, "mouseover", l);
|
|
this._popper && this._popper.destroy(),
|
|
this._menu.classList.remove(Ge),
|
|
this._element.classList.remove(Ge),
|
|
this._element.setAttribute("aria-expanded", "false"),
|
|
H.removeDataAttribute(this._menu, "popper"),
|
|
I.trigger(this._element, "hidden.bs.dropdown", t)
|
|
}
|
|
}
|
|
_getConfig(t) {
|
|
if ("object" == typeof (t = super._getConfig(t)).reference && !n(t.reference) && "function" != typeof t.reference.getBoundingClientRect)
|
|
throw new TypeError(`${Ke.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);
|
|
return t
|
|
}
|
|
_createPopper() {
|
|
if (void 0 === Ve)
|
|
throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org)");
|
|
let t = this._element;
|
|
"parent" === this._config.reference ? t = this._parent : n(this._config.reference) ? t = s(this._config.reference) : "object" == typeof this._config.reference && (t = this._config.reference);
|
|
const e = this._getPopperConfig();
|
|
this._popper = qe(t, this._menu, e)
|
|
}
|
|
_isShown() {
|
|
return this._menu.classList.contains(Ge)
|
|
}
|
|
_getPlacement() {
|
|
const t = this._parent;
|
|
if (t.classList.contains("dropend"))
|
|
return oi;
|
|
if (t.classList.contains("dropstart"))
|
|
return ri;
|
|
if (t.classList.contains("dropup-center"))
|
|
return "top";
|
|
if (t.classList.contains("dropdown-center"))
|
|
return "bottom";
|
|
const e = "end" === getComputedStyle(this._menu).getPropertyValue("--bs-position").trim();
|
|
return t.classList.contains("dropup") ? e ? ii : ei : e ? si : ni
|
|
}
|
|
_detectNavbar() {
|
|
return null !== this._element.closest(".navbar")
|
|
}
|
|
_getOffset() {
|
|
const {offset: t} = this._config;
|
|
return "string" == typeof t ? t.split(",").map((t => Number.parseInt(t, 10))) : "function" == typeof t ? e => t(e, this._element) : t
|
|
}
|
|
_getPopperConfig() {
|
|
const t = {
|
|
placement: this._getPlacement(),
|
|
modifiers: [{
|
|
name: "preventOverflow",
|
|
options: {
|
|
boundary: this._config.boundary
|
|
}
|
|
}, {
|
|
name: "offset",
|
|
options: {
|
|
offset: this._getOffset()
|
|
}
|
|
}]
|
|
};
|
|
return (this._inNavbar || "static" === this._config.display) && (H.setDataAttribute(this._menu, "popper", "static"),
|
|
t.modifiers = [{
|
|
name: "applyStyles",
|
|
enabled: !1
|
|
}]),
|
|
{
|
|
...t,
|
|
...p(this._config.popperConfig, [t])
|
|
}
|
|
}
|
|
_selectMenuItem({key: t, target: e}) {
|
|
const i = z.find(".dropdown-menu .dropdown-item:not(.disabled):not(:disabled)", this._menu).filter((t => o(t)));
|
|
i.length && g(i, e, t === Xe, !i.includes(e)).focus()
|
|
}
|
|
static jQueryInterface(t) {
|
|
return this.each((function() {
|
|
const e = ci.getOrCreateInstance(this, t);
|
|
if ("string" == typeof t) {
|
|
if (void 0 === e[t])
|
|
throw new TypeError(`No method named "${t}"`);
|
|
e[t]()
|
|
}
|
|
}
|
|
))
|
|
}
|
|
static clearMenus(t) {
|
|
if (2 === t.button || "keyup" === t.type && "Tab" !== t.key)
|
|
return;
|
|
const e = z.find(Ze);
|
|
for (const i of e) {
|
|
const e = ci.getInstance(i);
|
|
if (!e || !1 === e._config.autoClose)
|
|
continue;
|
|
const n = t.composedPath()
|
|
, s = n.includes(e._menu);
|
|
if (n.includes(e._element) || "inside" === e._config.autoClose && !s || "outside" === e._config.autoClose && s)
|
|
continue;
|
|
if (e._menu.contains(t.target) && ("keyup" === t.type && "Tab" === t.key || /input|select|option|textarea|form/i.test(t.target.tagName)))
|
|
continue;
|
|
const o = {
|
|
relatedTarget: e._element
|
|
};
|
|
"click" === t.type && (o.clickEvent = t),
|
|
e._completeHide(o)
|
|
}
|
|
}
|
|
static dataApiKeydownHandler(t) {
|
|
const e = /input|textarea/i.test(t.target.tagName)
|
|
, i = "Escape" === t.key
|
|
, n = [Qe, Xe].includes(t.key);
|
|
if (!n && !i)
|
|
return;
|
|
if (e && !i)
|
|
return;
|
|
t.preventDefault();
|
|
const s = this.matches(Je) ? this : z.prev(this, Je)[0] || z.next(this, Je)[0] || z.findOne(Je, t.delegateTarget.parentNode)
|
|
, o = ci.getOrCreateInstance(s);
|
|
if (n)
|
|
return t.stopPropagation(),
|
|
o.show(),
|
|
void o._selectMenuItem(t);
|
|
o._isShown() && (t.stopPropagation(),
|
|
o.hide(),
|
|
s.focus())
|
|
}
|
|
}
|
|
I.on(document, Ue, Je, ci.dataApiKeydownHandler),
|
|
I.on(document, Ue, ti, ci.dataApiKeydownHandler),
|
|
I.on(document, Ye, ci.clearMenus),
|
|
I.on(document, "keyup.bs.dropdown.data-api", ci.clearMenus),
|
|
I.on(document, Ye, Je, (function(t) {
|
|
t.preventDefault(),
|
|
ci.getOrCreateInstance(this).toggle()
|
|
}
|
|
)),
|
|
f(ci);
|
|
const hi = ".fixed-top, .fixed-bottom, .is-fixed, .sticky-top"
|
|
, di = ".sticky-top"
|
|
, ui = "padding-right"
|
|
, fi = "margin-right";
|
|
class pi {
|
|
constructor() {
|
|
this._element = document.body
|
|
}
|
|
getWidth() {
|
|
const t = document.documentElement.clientWidth;
|
|
return Math.abs(window.innerWidth - t)
|
|
}
|
|
hide() {
|
|
const t = this.getWidth();
|
|
this._disableOverFlow(),
|
|
this._setElementAttributes(this._element, ui, (e => e + t)),
|
|
this._setElementAttributes(hi, ui, (e => e + t)),
|
|
this._setElementAttributes(di, fi, (e => e - t))
|
|
}
|
|
reset() {
|
|
this._resetElementAttributes(this._element, "overflow"),
|
|
this._resetElementAttributes(this._element, ui),
|
|
this._resetElementAttributes(hi, ui),
|
|
this._resetElementAttributes(di, fi)
|
|
}
|
|
isOverflowing() {
|
|
return this.getWidth() > 0
|
|
}
|
|
_disableOverFlow() {
|
|
this._saveInitialAttribute(this._element, "overflow"),
|
|
this._element.style.overflow = "hidden"
|
|
}
|
|
_setElementAttributes(t, e, i) {
|
|
const n = this.getWidth();
|
|
this._applyManipulationCallback(t, (t => {
|
|
if (t !== this._element && window.innerWidth > t.clientWidth + n)
|
|
return;
|
|
this._saveInitialAttribute(t, e);
|
|
const s = window.getComputedStyle(t).getPropertyValue(e);
|
|
t.style.setProperty(e, `${i(Number.parseFloat(s))}px`)
|
|
}
|
|
))
|
|
}
|
|
_saveInitialAttribute(t, e) {
|
|
const i = t.style.getPropertyValue(e);
|
|
i && H.setDataAttribute(t, e, i)
|
|
}
|
|
_resetElementAttributes(t, e) {
|
|
this._applyManipulationCallback(t, (t => {
|
|
const i = H.getDataAttribute(t, e);
|
|
null !== i ? (H.removeDataAttribute(t, e),
|
|
t.style.setProperty(e, i)) : t.style.removeProperty(e)
|
|
}
|
|
))
|
|
}
|
|
_applyManipulationCallback(t, e) {
|
|
if (n(t))
|
|
e(t);
|
|
else
|
|
for (const i of z.find(t, this._element))
|
|
e(i)
|
|
}
|
|
}
|
|
const mi = "show"
|
|
, gi = "mousedown.bs.backdrop"
|
|
, _i = {
|
|
className: "modal-backdrop",
|
|
clickCallback: null,
|
|
isAnimated: !1,
|
|
isVisible: !0,
|
|
rootElement: "body"
|
|
}
|
|
, bi = {
|
|
className: "string",
|
|
clickCallback: "(function|null)",
|
|
isAnimated: "boolean",
|
|
isVisible: "boolean",
|
|
rootElement: "(element|string)"
|
|
};
|
|
class vi extends $ {
|
|
constructor(t) {
|
|
super(),
|
|
this._config = this._getConfig(t),
|
|
this._isAppended = !1,
|
|
this._element = null
|
|
}
|
|
static get Default() {
|
|
return _i
|
|
}
|
|
static get DefaultType() {
|
|
return bi
|
|
}
|
|
static get NAME() {
|
|
return "backdrop"
|
|
}
|
|
show(t) {
|
|
if (!this._config.isVisible)
|
|
return void p(t);
|
|
this._append();
|
|
const e = this._getElement();
|
|
this._config.isAnimated && c(e),
|
|
e.classList.add(mi),
|
|
this._emulateAnimation(( () => {
|
|
p(t)
|
|
}
|
|
))
|
|
}
|
|
hide(t) {
|
|
this._config.isVisible ? (this._getElement().classList.remove(mi),
|
|
this._emulateAnimation(( () => {
|
|
this.dispose(),
|
|
p(t)
|
|
}
|
|
))) : p(t)
|
|
}
|
|
dispose() {
|
|
this._isAppended && (I.off(this._element, gi),
|
|
this._element.remove(),
|
|
this._isAppended = !1)
|
|
}
|
|
_getElement() {
|
|
if (!this._element) {
|
|
const t = document.createElement("div");
|
|
t.className = this._config.className,
|
|
this._config.isAnimated && t.classList.add("fade"),
|
|
this._element = t
|
|
}
|
|
return this._element
|
|
}
|
|
_configAfterMerge(t) {
|
|
return t.rootElement = s(t.rootElement),
|
|
t
|
|
}
|
|
_append() {
|
|
if (this._isAppended)
|
|
return;
|
|
const t = this._getElement();
|
|
this._config.rootElement.append(t),
|
|
I.on(t, gi, ( () => {
|
|
p(this._config.clickCallback)
|
|
}
|
|
)),
|
|
this._isAppended = !0
|
|
}
|
|
_emulateAnimation(t) {
|
|
m(t, this._getElement(), this._config.isAnimated)
|
|
}
|
|
}
|
|
const yi = ".bs.focustrap"
|
|
, wi = "backward"
|
|
, Ai = {
|
|
autofocus: !0,
|
|
trapElement: null
|
|
}
|
|
, Ei = {
|
|
autofocus: "boolean",
|
|
trapElement: "element"
|
|
};
|
|
class Ti extends $ {
|
|
constructor(t) {
|
|
super(),
|
|
this._config = this._getConfig(t),
|
|
this._isActive = !1,
|
|
this._lastTabNavDirection = null
|
|
}
|
|
static get Default() {
|
|
return Ai
|
|
}
|
|
static get DefaultType() {
|
|
return Ei
|
|
}
|
|
static get NAME() {
|
|
return "focustrap"
|
|
}
|
|
activate() {
|
|
this._isActive || (this._config.autofocus && this._config.trapElement.focus(),
|
|
I.off(document, yi),
|
|
I.on(document, "focusin.bs.focustrap", (t => this._handleFocusin(t))),
|
|
I.on(document, "keydown.tab.bs.focustrap", (t => this._handleKeydown(t))),
|
|
this._isActive = !0)
|
|
}
|
|
deactivate() {
|
|
this._isActive && (this._isActive = !1,
|
|
I.off(document, yi))
|
|
}
|
|
_handleFocusin(t) {
|
|
const {trapElement: e} = this._config;
|
|
if (t.target === document || t.target === e || e.contains(t.target))
|
|
return;
|
|
const i = z.focusableChildren(e);
|
|
0 === i.length ? e.focus() : this._lastTabNavDirection === wi ? i[i.length - 1].focus() : i[0].focus()
|
|
}
|
|
_handleKeydown(t) {
|
|
"Tab" === t.key && (this._lastTabNavDirection = t.shiftKey ? wi : "forward")
|
|
}
|
|
}
|
|
const Ci = "hidden.bs.modal"
|
|
, Oi = "show.bs.modal"
|
|
, xi = "modal-open"
|
|
, ki = "show"
|
|
, Li = "modal-static"
|
|
, Si = {
|
|
backdrop: !0,
|
|
focus: !0,
|
|
keyboard: !0
|
|
}
|
|
, Di = {
|
|
backdrop: "(boolean|string)",
|
|
focus: "boolean",
|
|
keyboard: "boolean"
|
|
};
|
|
class Ii extends W {
|
|
constructor(t, e) {
|
|
super(t, e),
|
|
this._dialog = z.findOne(".modal-dialog", this._element),
|
|
this._backdrop = this._initializeBackDrop(),
|
|
this._focustrap = this._initializeFocusTrap(),
|
|
this._isShown = !1,
|
|
this._isTransitioning = !1,
|
|
this._scrollBar = new pi,
|
|
this._addEventListeners()
|
|
}
|
|
static get Default() {
|
|
return Si
|
|
}
|
|
static get DefaultType() {
|
|
return Di
|
|
}
|
|
static get NAME() {
|
|
return "modal"
|
|
}
|
|
toggle(t) {
|
|
return this._isShown ? this.hide() : this.show(t)
|
|
}
|
|
show(t) {
|
|
this._isShown || this._isTransitioning || I.trigger(this._element, Oi, {
|
|
relatedTarget: t
|
|
}).defaultPrevented || (this._isShown = !0,
|
|
this._isTransitioning = !0,
|
|
this._scrollBar.hide(),
|
|
document.body.classList.add(xi),
|
|
this._adjustDialog(),
|
|
this._backdrop.show(( () => this._showElement(t))))
|
|
}
|
|
hide() {
|
|
this._isShown && !this._isTransitioning && (I.trigger(this._element, "hide.bs.modal").defaultPrevented || (this._isShown = !1,
|
|
this._isTransitioning = !0,
|
|
this._focustrap.deactivate(),
|
|
this._element.classList.remove(ki),
|
|
this._queueCallback(( () => this._hideModal()), this._element, this._isAnimated())))
|
|
}
|
|
dispose() {
|
|
for (const t of [window, this._dialog])
|
|
I.off(t, ".bs.modal");
|
|
this._backdrop.dispose(),
|
|
this._focustrap.deactivate(),
|
|
super.dispose()
|
|
}
|
|
handleUpdate() {
|
|
this._adjustDialog()
|
|
}
|
|
_initializeBackDrop() {
|
|
return new vi({
|
|
isVisible: Boolean(this._config.backdrop),
|
|
isAnimated: this._isAnimated()
|
|
})
|
|
}
|
|
_initializeFocusTrap() {
|
|
return new Ti({
|
|
trapElement: this._element
|
|
})
|
|
}
|
|
_showElement(t) {
|
|
document.body.contains(this._element) || document.body.append(this._element),
|
|
this._element.style.display = "block",
|
|
this._element.removeAttribute("aria-hidden"),
|
|
this._element.setAttribute("aria-modal", !0),
|
|
this._element.setAttribute("role", "dialog"),
|
|
this._element.scrollTop = 0;
|
|
const e = z.findOne(".modal-body", this._dialog);
|
|
e && (e.scrollTop = 0),
|
|
c(this._element),
|
|
this._element.classList.add(ki),
|
|
this._queueCallback(( () => {
|
|
this._config.focus && this._focustrap.activate(),
|
|
this._isTransitioning = !1,
|
|
I.trigger(this._element, "shown.bs.modal", {
|
|
relatedTarget: t
|
|
})
|
|
}
|
|
), this._dialog, this._isAnimated())
|
|
}
|
|
_addEventListeners() {
|
|
I.on(this._element, "keydown.dismiss.bs.modal", (t => {
|
|
if ("Escape" === t.key)
|
|
return this._config.keyboard ? (t.preventDefault(),
|
|
void this.hide()) : void this._triggerBackdropTransition()
|
|
}
|
|
)),
|
|
I.on(window, "resize.bs.modal", ( () => {
|
|
this._isShown && !this._isTransitioning && this._adjustDialog()
|
|
}
|
|
)),
|
|
I.on(this._element, "mousedown.dismiss.bs.modal", (t => {
|
|
I.one(this._element, "click.dismiss.bs.modal", (e => {
|
|
this._element === t.target && this._element === e.target && ("static" !== this._config.backdrop ? this._config.backdrop && this.hide() : this._triggerBackdropTransition())
|
|
}
|
|
))
|
|
}
|
|
))
|
|
}
|
|
_hideModal() {
|
|
this._element.style.display = "none",
|
|
this._element.setAttribute("aria-hidden", !0),
|
|
this._element.removeAttribute("aria-modal"),
|
|
this._element.removeAttribute("role"),
|
|
this._isTransitioning = !1,
|
|
this._backdrop.hide(( () => {
|
|
document.body.classList.remove(xi),
|
|
this._resetAdjustments(),
|
|
this._scrollBar.reset(),
|
|
I.trigger(this._element, Ci)
|
|
}
|
|
))
|
|
}
|
|
_isAnimated() {
|
|
return this._element.classList.contains("fade")
|
|
}
|
|
_triggerBackdropTransition() {
|
|
if (I.trigger(this._element, "hidePrevented.bs.modal").defaultPrevented)
|
|
return;
|
|
const t = this._element.scrollHeight > document.documentElement.clientHeight
|
|
, e = this._element.style.overflowY;
|
|
"hidden" === e || this._element.classList.contains(Li) || (t || (this._element.style.overflowY = "hidden"),
|
|
this._element.classList.add(Li),
|
|
this._queueCallback(( () => {
|
|
this._element.classList.remove(Li),
|
|
this._queueCallback(( () => {
|
|
this._element.style.overflowY = e
|
|
}
|
|
), this._dialog)
|
|
}
|
|
), this._dialog),
|
|
this._element.focus())
|
|
}
|
|
_adjustDialog() {
|
|
const t = this._element.scrollHeight > document.documentElement.clientHeight
|
|
, e = this._scrollBar.getWidth()
|
|
, i = e > 0;
|
|
if (i && !t) {
|
|
const t = u() ? "paddingLeft" : "paddingRight";
|
|
this._element.style[t] = `${e}px`
|
|
}
|
|
if (!i && t) {
|
|
const t = u() ? "paddingRight" : "paddingLeft";
|
|
this._element.style[t] = `${e}px`
|
|
}
|
|
}
|
|
_resetAdjustments() {
|
|
this._element.style.paddingLeft = "",
|
|
this._element.style.paddingRight = ""
|
|
}
|
|
static jQueryInterface(t, e) {
|
|
return this.each((function() {
|
|
const i = Ii.getOrCreateInstance(this, t);
|
|
if ("string" == typeof t) {
|
|
if (void 0 === i[t])
|
|
throw new TypeError(`No method named "${t}"`);
|
|
i[t](e)
|
|
}
|
|
}
|
|
))
|
|
}
|
|
}
|
|
I.on(document, "click.bs.modal.data-api", '[data-bs-toggle="modal"]', (function(t) {
|
|
const e = z.getElementFromSelector(this);
|
|
["A", "AREA"].includes(this.tagName) && t.preventDefault(),
|
|
I.one(e, Oi, (t => {
|
|
t.defaultPrevented || I.one(e, Ci, ( () => {
|
|
o(this) && this.focus()
|
|
}
|
|
))
|
|
}
|
|
));
|
|
const i = z.findOne(".modal.show");
|
|
i && Ii.getInstance(i).hide(),
|
|
Ii.getOrCreateInstance(e).toggle(this)
|
|
}
|
|
)),
|
|
R(Ii),
|
|
f(Ii);
|
|
const Ni = "show"
|
|
, Pi = "showing"
|
|
, ji = "hiding"
|
|
, Mi = ".offcanvas.show"
|
|
, Fi = "hidePrevented.bs.offcanvas"
|
|
, Hi = "hidden.bs.offcanvas"
|
|
, $i = {
|
|
backdrop: !0,
|
|
keyboard: !0,
|
|
scroll: !1
|
|
}
|
|
, Wi = {
|
|
backdrop: "(boolean|string)",
|
|
keyboard: "boolean",
|
|
scroll: "boolean"
|
|
};
|
|
class Bi extends W {
|
|
constructor(t, e) {
|
|
super(t, e),
|
|
this._isShown = !1,
|
|
this._backdrop = this._initializeBackDrop(),
|
|
this._focustrap = this._initializeFocusTrap(),
|
|
this._addEventListeners()
|
|
}
|
|
static get Default() {
|
|
return $i
|
|
}
|
|
static get DefaultType() {
|
|
return Wi
|
|
}
|
|
static get NAME() {
|
|
return "offcanvas"
|
|
}
|
|
toggle(t) {
|
|
return this._isShown ? this.hide() : this.show(t)
|
|
}
|
|
show(t) {
|
|
this._isShown || I.trigger(this._element, "show.bs.offcanvas", {
|
|
relatedTarget: t
|
|
}).defaultPrevented || (this._isShown = !0,
|
|
this._backdrop.show(),
|
|
this._config.scroll || (new pi).hide(),
|
|
this._element.setAttribute("aria-modal", !0),
|
|
this._element.setAttribute("role", "dialog"),
|
|
this._element.classList.add(Pi),
|
|
this._queueCallback(( () => {
|
|
this._config.scroll && !this._config.backdrop || this._focustrap.activate(),
|
|
this._element.classList.add(Ni),
|
|
this._element.classList.remove(Pi),
|
|
I.trigger(this._element, "shown.bs.offcanvas", {
|
|
relatedTarget: t
|
|
})
|
|
}
|
|
), this._element, !0))
|
|
}
|
|
hide() {
|
|
this._isShown && (I.trigger(this._element, "hide.bs.offcanvas").defaultPrevented || (this._focustrap.deactivate(),
|
|
this._element.blur(),
|
|
this._isShown = !1,
|
|
this._element.classList.add(ji),
|
|
this._backdrop.hide(),
|
|
this._queueCallback(( () => {
|
|
this._element.classList.remove(Ni, ji),
|
|
this._element.removeAttribute("aria-modal"),
|
|
this._element.removeAttribute("role"),
|
|
this._config.scroll || (new pi).reset(),
|
|
I.trigger(this._element, Hi)
|
|
}
|
|
), this._element, !0)))
|
|
}
|
|
dispose() {
|
|
this._backdrop.dispose(),
|
|
this._focustrap.deactivate(),
|
|
super.dispose()
|
|
}
|
|
_initializeBackDrop() {
|
|
const t = Boolean(this._config.backdrop);
|
|
return new vi({
|
|
className: "offcanvas-backdrop",
|
|
isVisible: t,
|
|
isAnimated: !0,
|
|
rootElement: this._element.parentNode,
|
|
clickCallback: t ? () => {
|
|
"static" !== this._config.backdrop ? this.hide() : I.trigger(this._element, Fi)
|
|
}
|
|
: null
|
|
})
|
|
}
|
|
_initializeFocusTrap() {
|
|
return new Ti({
|
|
trapElement: this._element
|
|
})
|
|
}
|
|
_addEventListeners() {
|
|
I.on(this._element, "keydown.dismiss.bs.offcanvas", (t => {
|
|
"Escape" === t.key && (this._config.keyboard ? this.hide() : I.trigger(this._element, Fi))
|
|
}
|
|
))
|
|
}
|
|
static jQueryInterface(t) {
|
|
return this.each((function() {
|
|
const e = Bi.getOrCreateInstance(this, t);
|
|
if ("string" == typeof t) {
|
|
if (void 0 === e[t] || t.startsWith("_") || "constructor" === t)
|
|
throw new TypeError(`No method named "${t}"`);
|
|
e[t](this)
|
|
}
|
|
}
|
|
))
|
|
}
|
|
}
|
|
I.on(document, "click.bs.offcanvas.data-api", '[data-bs-toggle="offcanvas"]', (function(t) {
|
|
const e = z.getElementFromSelector(this);
|
|
if (["A", "AREA"].includes(this.tagName) && t.preventDefault(),
|
|
r(this))
|
|
return;
|
|
I.one(e, Hi, ( () => {
|
|
o(this) && this.focus()
|
|
}
|
|
));
|
|
const i = z.findOne(Mi);
|
|
i && i !== e && Bi.getInstance(i).hide(),
|
|
Bi.getOrCreateInstance(e).toggle(this)
|
|
}
|
|
)),
|
|
I.on(window, "load.bs.offcanvas.data-api", ( () => {
|
|
for (const t of z.find(Mi))
|
|
Bi.getOrCreateInstance(t).show()
|
|
}
|
|
)),
|
|
I.on(window, "resize.bs.offcanvas", ( () => {
|
|
for (const t of z.find("[aria-modal][class*=show][class*=offcanvas-]"))
|
|
"fixed" !== getComputedStyle(t).position && Bi.getOrCreateInstance(t).hide()
|
|
}
|
|
)),
|
|
R(Bi),
|
|
f(Bi);
|
|
const zi = new Set(["background", "cite", "href", "itemtype", "longdesc", "poster", "src", "xlink:href"])
|
|
, Ri = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i
|
|
, qi = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i
|
|
, Vi = (t, e) => {
|
|
const i = t.nodeName.toLowerCase();
|
|
return e.includes(i) ? !zi.has(i) || Boolean(Ri.test(t.nodeValue) || qi.test(t.nodeValue)) : e.filter((t => t instanceof RegExp)).some((t => t.test(i)))
|
|
}
|
|
, Ki = {
|
|
"*": ["class", "dir", "id", "lang", "role", /^aria-[\w-]*$/i],
|
|
a: ["target", "href", "title", "rel"],
|
|
area: [],
|
|
b: [],
|
|
br: [],
|
|
col: [],
|
|
code: [],
|
|
div: [],
|
|
em: [],
|
|
hr: [],
|
|
h1: [],
|
|
h2: [],
|
|
h3: [],
|
|
h4: [],
|
|
h5: [],
|
|
h6: [],
|
|
i: [],
|
|
img: ["src", "srcset", "alt", "title", "width", "height"],
|
|
li: [],
|
|
ol: [],
|
|
p: [],
|
|
pre: [],
|
|
s: [],
|
|
small: [],
|
|
span: [],
|
|
sub: [],
|
|
sup: [],
|
|
strong: [],
|
|
u: [],
|
|
ul: []
|
|
}
|
|
, Qi = {
|
|
allowList: Ki,
|
|
content: {},
|
|
extraClass: "",
|
|
html: !1,
|
|
sanitize: !0,
|
|
sanitizeFn: null,
|
|
template: "<div></div>"
|
|
}
|
|
, Xi = {
|
|
allowList: "object",
|
|
content: "object",
|
|
extraClass: "(string|function)",
|
|
html: "boolean",
|
|
sanitize: "boolean",
|
|
sanitizeFn: "(null|function)",
|
|
template: "string"
|
|
}
|
|
, Yi = {
|
|
entry: "(string|element|function|null)",
|
|
selector: "(string|element)"
|
|
};
|
|
class Ui extends $ {
|
|
constructor(t) {
|
|
super(),
|
|
this._config = this._getConfig(t)
|
|
}
|
|
static get Default() {
|
|
return Qi
|
|
}
|
|
static get DefaultType() {
|
|
return Xi
|
|
}
|
|
static get NAME() {
|
|
return "TemplateFactory"
|
|
}
|
|
getContent() {
|
|
return Object.values(this._config.content).map((t => this._resolvePossibleFunction(t))).filter(Boolean)
|
|
}
|
|
hasContent() {
|
|
return this.getContent().length > 0
|
|
}
|
|
changeContent(t) {
|
|
return this._checkContent(t),
|
|
this._config.content = {
|
|
...this._config.content,
|
|
...t
|
|
},
|
|
this
|
|
}
|
|
toHtml() {
|
|
const t = document.createElement("div");
|
|
t.innerHTML = this._maybeSanitize(this._config.template);
|
|
for (const [e,i] of Object.entries(this._config.content))
|
|
this._setContent(t, i, e);
|
|
const e = t.children[0]
|
|
, i = this._resolvePossibleFunction(this._config.extraClass);
|
|
return i && e.classList.add(...i.split(" ")),
|
|
e
|
|
}
|
|
_typeCheckConfig(t) {
|
|
super._typeCheckConfig(t),
|
|
this._checkContent(t.content)
|
|
}
|
|
_checkContent(t) {
|
|
for (const [e,i] of Object.entries(t))
|
|
super._typeCheckConfig({
|
|
selector: e,
|
|
entry: i
|
|
}, Yi)
|
|
}
|
|
_setContent(t, e, i) {
|
|
const o = z.findOne(i, t);
|
|
o && ((e = this._resolvePossibleFunction(e)) ? n(e) ? this._putElementInTemplate(s(e), o) : this._config.html ? o.innerHTML = this._maybeSanitize(e) : o.textContent = e : o.remove())
|
|
}
|
|
_maybeSanitize(t) {
|
|
return this._config.sanitize ? function(t, e, i) {
|
|
if (!t.length)
|
|
return t;
|
|
if (i && "function" == typeof i)
|
|
return i(t);
|
|
const n = (new window.DOMParser).parseFromString(t, "text/html")
|
|
, s = [].concat(...n.body.querySelectorAll("*"));
|
|
for (const t of s) {
|
|
const i = t.nodeName.toLowerCase();
|
|
if (!Object.keys(e).includes(i)) {
|
|
t.remove();
|
|
continue
|
|
}
|
|
const n = [].concat(...t.attributes)
|
|
, s = [].concat(e["*"] || [], e[i] || []);
|
|
for (const e of n)
|
|
Vi(e, s) || t.removeAttribute(e.nodeName)
|
|
}
|
|
return n.body.innerHTML
|
|
}(t, this._config.allowList, this._config.sanitizeFn) : t
|
|
}
|
|
_resolvePossibleFunction(t) {
|
|
return p(t, [this])
|
|
}
|
|
_putElementInTemplate(t, e) {
|
|
if (this._config.html)
|
|
return e.innerHTML = "",
|
|
void e.append(t);
|
|
e.textContent = t.textContent
|
|
}
|
|
}
|
|
const Gi = new Set(["sanitize", "allowList", "sanitizeFn"])
|
|
, Ji = "fade"
|
|
, Zi = "show"
|
|
, tn = ".modal"
|
|
, en = "hide.bs.modal"
|
|
, nn = "hover"
|
|
, sn = "focus"
|
|
, on = {
|
|
AUTO: "auto",
|
|
TOP: "top",
|
|
RIGHT: u() ? "left" : "right",
|
|
BOTTOM: "bottom",
|
|
LEFT: u() ? "right" : "left"
|
|
}
|
|
, rn = {
|
|
allowList: Ki,
|
|
animation: !0,
|
|
boundary: "clippingParents",
|
|
container: !1,
|
|
customClass: "",
|
|
delay: 0,
|
|
fallbackPlacements: ["top", "right", "bottom", "left"],
|
|
html: !1,
|
|
offset: [0, 0],
|
|
placement: "top",
|
|
popperConfig: null,
|
|
sanitize: !0,
|
|
sanitizeFn: null,
|
|
selector: !1,
|
|
template: '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
|
|
title: "",
|
|
trigger: "hover focus"
|
|
}
|
|
, an = {
|
|
allowList: "object",
|
|
animation: "boolean",
|
|
boundary: "(string|element)",
|
|
container: "(string|element|boolean)",
|
|
customClass: "(string|function)",
|
|
delay: "(number|object)",
|
|
fallbackPlacements: "array",
|
|
html: "boolean",
|
|
offset: "(array|string|function)",
|
|
placement: "(string|function)",
|
|
popperConfig: "(null|object|function)",
|
|
sanitize: "boolean",
|
|
sanitizeFn: "(null|function)",
|
|
selector: "(string|boolean)",
|
|
template: "string",
|
|
title: "(string|element|function)",
|
|
trigger: "string"
|
|
};
|
|
class ln extends W {
|
|
constructor(t, e) {
|
|
if (void 0 === Ve)
|
|
throw new TypeError("Bootstrap's tooltips require Popper (https://popper.js.org)");
|
|
super(t, e),
|
|
this._isEnabled = !0,
|
|
this._timeout = 0,
|
|
this._isHovered = null,
|
|
this._activeTrigger = {},
|
|
this._popper = null,
|
|
this._templateFactory = null,
|
|
this._newContent = null,
|
|
this.tip = null,
|
|
this._setListeners(),
|
|
this._config.selector || this._fixTitle()
|
|
}
|
|
static get Default() {
|
|
return rn
|
|
}
|
|
static get DefaultType() {
|
|
return an
|
|
}
|
|
static get NAME() {
|
|
return "tooltip"
|
|
}
|
|
enable() {
|
|
this._isEnabled = !0
|
|
}
|
|
disable() {
|
|
this._isEnabled = !1
|
|
}
|
|
toggleEnabled() {
|
|
this._isEnabled = !this._isEnabled
|
|
}
|
|
toggle() {
|
|
this._isEnabled && (this._activeTrigger.click = !this._activeTrigger.click,
|
|
this._isShown() ? this._leave() : this._enter())
|
|
}
|
|
dispose() {
|
|
clearTimeout(this._timeout),
|
|
I.off(this._element.closest(tn), en, this._hideModalHandler),
|
|
this._element.getAttribute("data-bs-original-title") && this._element.setAttribute("title", this._element.getAttribute("data-bs-original-title")),
|
|
this._disposePopper(),
|
|
super.dispose()
|
|
}
|
|
show() {
|
|
if ("none" === this._element.style.display)
|
|
throw new Error("Please use show on visible elements");
|
|
if (!this._isWithContent() || !this._isEnabled)
|
|
return;
|
|
const t = I.trigger(this._element, this.constructor.eventName("show"))
|
|
, e = (a(this._element) || this._element.ownerDocument.documentElement).contains(this._element);
|
|
if (t.defaultPrevented || !e)
|
|
return;
|
|
this._disposePopper();
|
|
const i = this._getTipElement();
|
|
this._element.setAttribute("aria-describedby", i.getAttribute("id"));
|
|
const {container: n} = this._config;
|
|
if (this._element.ownerDocument.documentElement.contains(this.tip) || (n.append(i),
|
|
I.trigger(this._element, this.constructor.eventName("inserted"))),
|
|
this._popper = this._createPopper(i),
|
|
i.classList.add(Zi),
|
|
"ontouchstart"in document.documentElement)
|
|
for (const t of [].concat(...document.body.children))
|
|
I.on(t, "mouseover", l);
|
|
this._queueCallback(( () => {
|
|
I.trigger(this._element, this.constructor.eventName("shown")),
|
|
!1 === this._isHovered && this._leave(),
|
|
this._isHovered = !1
|
|
}
|
|
), this.tip, this._isAnimated())
|
|
}
|
|
hide() {
|
|
if (this._isShown() && !I.trigger(this._element, this.constructor.eventName("hide")).defaultPrevented) {
|
|
if (this._getTipElement().classList.remove(Zi),
|
|
"ontouchstart"in document.documentElement)
|
|
for (const t of [].concat(...document.body.children))
|
|
I.off(t, "mouseover", l);
|
|
this._activeTrigger.click = !1,
|
|
this._activeTrigger.focus = !1,
|
|
this._activeTrigger.hover = !1,
|
|
this._isHovered = null,
|
|
this._queueCallback(( () => {
|
|
this._isWithActiveTrigger() || (this._isHovered || this._disposePopper(),
|
|
this._element.removeAttribute("aria-describedby"),
|
|
I.trigger(this._element, this.constructor.eventName("hidden")))
|
|
}
|
|
), this.tip, this._isAnimated())
|
|
}
|
|
}
|
|
update() {
|
|
this._popper && this._popper.update()
|
|
}
|
|
_isWithContent() {
|
|
return Boolean(this._getTitle())
|
|
}
|
|
_getTipElement() {
|
|
return this.tip || (this.tip = this._createTipElement(this._newContent || this._getContentForTemplate())),
|
|
this.tip
|
|
}
|
|
_createTipElement(t) {
|
|
const e = this._getTemplateFactory(t).toHtml();
|
|
if (!e)
|
|
return null;
|
|
e.classList.remove(Ji, Zi),
|
|
e.classList.add(`bs-${this.constructor.NAME}-auto`);
|
|
const i = (t => {
|
|
do {
|
|
t += Math.floor(1e6 * Math.random())
|
|
} while (document.getElementById(t));
|
|
return t
|
|
}
|
|
)(this.constructor.NAME).toString();
|
|
return e.setAttribute("id", i),
|
|
this._isAnimated() && e.classList.add(Ji),
|
|
e
|
|
}
|
|
setContent(t) {
|
|
this._newContent = t,
|
|
this._isShown() && (this._disposePopper(),
|
|
this.show())
|
|
}
|
|
_getTemplateFactory(t) {
|
|
return this._templateFactory ? this._templateFactory.changeContent(t) : this._templateFactory = new Ui({
|
|
...this._config,
|
|
content: t,
|
|
extraClass: this._resolvePossibleFunction(this._config.customClass)
|
|
}),
|
|
this._templateFactory
|
|
}
|
|
_getContentForTemplate() {
|
|
return {
|
|
".tooltip-inner": this._getTitle()
|
|
}
|
|
}
|
|
_getTitle() {
|
|
return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute("data-bs-original-title")
|
|
}
|
|
_initializeOnDelegatedTarget(t) {
|
|
return this.constructor.getOrCreateInstance(t.delegateTarget, this._getDelegateConfig())
|
|
}
|
|
_isAnimated() {
|
|
return this._config.animation || this.tip && this.tip.classList.contains(Ji)
|
|
}
|
|
_isShown() {
|
|
return this.tip && this.tip.classList.contains(Zi)
|
|
}
|
|
_createPopper(t) {
|
|
const e = p(this._config.placement, [this, t, this._element])
|
|
, i = on[e.toUpperCase()];
|
|
return qe(this._element, t, this._getPopperConfig(i))
|
|
}
|
|
_getOffset() {
|
|
const {offset: t} = this._config;
|
|
return "string" == typeof t ? t.split(",").map((t => Number.parseInt(t, 10))) : "function" == typeof t ? e => t(e, this._element) : t
|
|
}
|
|
_resolvePossibleFunction(t) {
|
|
return p(t, [this._element])
|
|
}
|
|
_getPopperConfig(t) {
|
|
const e = {
|
|
placement: t,
|
|
modifiers: [{
|
|
name: "flip",
|
|
options: {
|
|
fallbackPlacements: this._config.fallbackPlacements
|
|
}
|
|
}, {
|
|
name: "offset",
|
|
options: {
|
|
offset: this._getOffset()
|
|
}
|
|
}, {
|
|
name: "preventOverflow",
|
|
options: {
|
|
boundary: this._config.boundary
|
|
}
|
|
}, {
|
|
name: "arrow",
|
|
options: {
|
|
element: `.${this.constructor.NAME}-arrow`
|
|
}
|
|
}, {
|
|
name: "preSetPlacement",
|
|
enabled: !0,
|
|
phase: "beforeMain",
|
|
fn: t => {
|
|
this._getTipElement().setAttribute("data-popper-placement", t.state.placement)
|
|
}
|
|
}]
|
|
};
|
|
return {
|
|
...e,
|
|
...p(this._config.popperConfig, [e])
|
|
}
|
|
}
|
|
_setListeners() {
|
|
const t = this._config.trigger.split(" ");
|
|
for (const e of t)
|
|
if ("click" === e)
|
|
I.on(this._element, this.constructor.eventName("click"), this._config.selector, (t => {
|
|
this._initializeOnDelegatedTarget(t).toggle()
|
|
}
|
|
));
|
|
else if ("manual" !== e) {
|
|
const t = e === nn ? this.constructor.eventName("mouseenter") : this.constructor.eventName("focusin")
|
|
, i = e === nn ? this.constructor.eventName("mouseleave") : this.constructor.eventName("focusout");
|
|
I.on(this._element, t, this._config.selector, (t => {
|
|
const e = this._initializeOnDelegatedTarget(t);
|
|
e._activeTrigger["focusin" === t.type ? sn : nn] = !0,
|
|
e._enter()
|
|
}
|
|
)),
|
|
I.on(this._element, i, this._config.selector, (t => {
|
|
const e = this._initializeOnDelegatedTarget(t);
|
|
e._activeTrigger["focusout" === t.type ? sn : nn] = e._element.contains(t.relatedTarget),
|
|
e._leave()
|
|
}
|
|
))
|
|
}
|
|
this._hideModalHandler = () => {
|
|
this._element && this.hide()
|
|
}
|
|
,
|
|
I.on(this._element.closest(tn), en, this._hideModalHandler)
|
|
}
|
|
_fixTitle() {
|
|
const t = this._element.getAttribute("title");
|
|
t && (this._element.getAttribute("aria-label") || this._element.textContent.trim() || this._element.setAttribute("aria-label", t),
|
|
this._element.setAttribute("data-bs-original-title", t),
|
|
this._element.removeAttribute("title"))
|
|
}
|
|
_enter() {
|
|
this._isShown() || this._isHovered ? this._isHovered = !0 : (this._isHovered = !0,
|
|
this._setTimeout(( () => {
|
|
this._isHovered && this.show()
|
|
}
|
|
), this._config.delay.show))
|
|
}
|
|
_leave() {
|
|
this._isWithActiveTrigger() || (this._isHovered = !1,
|
|
this._setTimeout(( () => {
|
|
this._isHovered || this.hide()
|
|
}
|
|
), this._config.delay.hide))
|
|
}
|
|
_setTimeout(t, e) {
|
|
clearTimeout(this._timeout),
|
|
this._timeout = setTimeout(t, e)
|
|
}
|
|
_isWithActiveTrigger() {
|
|
return Object.values(this._activeTrigger).includes(!0)
|
|
}
|
|
_getConfig(t) {
|
|
const e = H.getDataAttributes(this._element);
|
|
for (const t of Object.keys(e))
|
|
Gi.has(t) && delete e[t];
|
|
return t = {
|
|
...e,
|
|
..."object" == typeof t && t ? t : {}
|
|
},
|
|
t = this._mergeConfigObj(t),
|
|
t = this._configAfterMerge(t),
|
|
this._typeCheckConfig(t),
|
|
t
|
|
}
|
|
_configAfterMerge(t) {
|
|
return t.container = !1 === t.container ? document.body : s(t.container),
|
|
"number" == typeof t.delay && (t.delay = {
|
|
show: t.delay,
|
|
hide: t.delay
|
|
}),
|
|
"number" == typeof t.title && (t.title = t.title.toString()),
|
|
"number" == typeof t.content && (t.content = t.content.toString()),
|
|
t
|
|
}
|
|
_getDelegateConfig() {
|
|
const t = {};
|
|
for (const [e,i] of Object.entries(this._config))
|
|
this.constructor.Default[e] !== i && (t[e] = i);
|
|
return t.selector = !1,
|
|
t.trigger = "manual",
|
|
t
|
|
}
|
|
_disposePopper() {
|
|
this._popper && (this._popper.destroy(),
|
|
this._popper = null),
|
|
this.tip && (this.tip.remove(),
|
|
this.tip = null)
|
|
}
|
|
static jQueryInterface(t) {
|
|
return this.each((function() {
|
|
const e = ln.getOrCreateInstance(this, t);
|
|
if ("string" == typeof t) {
|
|
if (void 0 === e[t])
|
|
throw new TypeError(`No method named "${t}"`);
|
|
e[t]()
|
|
}
|
|
}
|
|
))
|
|
}
|
|
}
|
|
f(ln);
|
|
const cn = {
|
|
...ln.Default,
|
|
content: "",
|
|
offset: [0, 8],
|
|
placement: "right",
|
|
template: '<div class="popover" role="tooltip"><div class="popover-arrow"></div><h3 class="popover-header"></h3><div class="popover-body"></div></div>',
|
|
trigger: "click"
|
|
}
|
|
, hn = {
|
|
...ln.DefaultType,
|
|
content: "(null|string|element|function)"
|
|
};
|
|
class dn extends ln {
|
|
static get Default() {
|
|
return cn
|
|
}
|
|
static get DefaultType() {
|
|
return hn
|
|
}
|
|
static get NAME() {
|
|
return "popover"
|
|
}
|
|
_isWithContent() {
|
|
return this._getTitle() || this._getContent()
|
|
}
|
|
_getContentForTemplate() {
|
|
return {
|
|
".popover-header": this._getTitle(),
|
|
".popover-body": this._getContent()
|
|
}
|
|
}
|
|
_getContent() {
|
|
return this._resolvePossibleFunction(this._config.content)
|
|
}
|
|
static jQueryInterface(t) {
|
|
return this.each((function() {
|
|
const e = dn.getOrCreateInstance(this, t);
|
|
if ("string" == typeof t) {
|
|
if (void 0 === e[t])
|
|
throw new TypeError(`No method named "${t}"`);
|
|
e[t]()
|
|
}
|
|
}
|
|
))
|
|
}
|
|
}
|
|
f(dn);
|
|
const un = "click.bs.scrollspy"
|
|
, fn = "active"
|
|
, pn = "[href]"
|
|
, mn = {
|
|
offset: null,
|
|
rootMargin: "0px 0px -25%",
|
|
smoothScroll: !1,
|
|
target: null,
|
|
threshold: [.1, .5, 1]
|
|
}
|
|
, gn = {
|
|
offset: "(number|null)",
|
|
rootMargin: "string",
|
|
smoothScroll: "boolean",
|
|
target: "element",
|
|
threshold: "array"
|
|
};
|
|
class _n extends W {
|
|
constructor(t, e) {
|
|
super(t, e),
|
|
this._targetLinks = new Map,
|
|
this._observableSections = new Map,
|
|
this._rootElement = "visible" === getComputedStyle(this._element).overflowY ? null : this._element,
|
|
this._activeTarget = null,
|
|
this._observer = null,
|
|
this._previousScrollData = {
|
|
visibleEntryTop: 0,
|
|
parentScrollTop: 0
|
|
},
|
|
this.refresh()
|
|
}
|
|
static get Default() {
|
|
return mn
|
|
}
|
|
static get DefaultType() {
|
|
return gn
|
|
}
|
|
static get NAME() {
|
|
return "scrollspy"
|
|
}
|
|
refresh() {
|
|
this._initializeTargetsAndObservables(),
|
|
this._maybeEnableSmoothScroll(),
|
|
this._observer ? this._observer.disconnect() : this._observer = this._getNewObserver();
|
|
for (const t of this._observableSections.values())
|
|
this._observer.observe(t)
|
|
}
|
|
dispose() {
|
|
this._observer.disconnect(),
|
|
super.dispose()
|
|
}
|
|
_configAfterMerge(t) {
|
|
return t.target = s(t.target) || document.body,
|
|
t.rootMargin = t.offset ? `${t.offset}px 0px -30%` : t.rootMargin,
|
|
"string" == typeof t.threshold && (t.threshold = t.threshold.split(",").map((t => Number.parseFloat(t)))),
|
|
t
|
|
}
|
|
_maybeEnableSmoothScroll() {
|
|
this._config.smoothScroll && (I.off(this._config.target, un),
|
|
I.on(this._config.target, un, pn, (t => {
|
|
const e = this._observableSections.get(t.target.hash);
|
|
if (e) {
|
|
t.preventDefault();
|
|
const i = this._rootElement || window
|
|
, n = e.offsetTop - this._element.offsetTop;
|
|
if (i.scrollTo)
|
|
return void i.scrollTo({
|
|
top: n,
|
|
behavior: "smooth"
|
|
});
|
|
i.scrollTop = n
|
|
}
|
|
}
|
|
)))
|
|
}
|
|
_getNewObserver() {
|
|
const t = {
|
|
root: this._rootElement,
|
|
threshold: this._config.threshold,
|
|
rootMargin: this._config.rootMargin
|
|
};
|
|
return new IntersectionObserver((t => this._observerCallback(t)),t)
|
|
}
|
|
_observerCallback(t) {
|
|
const e = t => this._targetLinks.get(`#${t.target.id}`)
|
|
, i = t => {
|
|
this._previousScrollData.visibleEntryTop = t.target.offsetTop,
|
|
this._process(e(t))
|
|
}
|
|
, n = (this._rootElement || document.documentElement).scrollTop
|
|
, s = n >= this._previousScrollData.parentScrollTop;
|
|
this._previousScrollData.parentScrollTop = n;
|
|
for (const o of t) {
|
|
if (!o.isIntersecting) {
|
|
this._activeTarget = null,
|
|
this._clearActiveClass(e(o));
|
|
continue
|
|
}
|
|
const t = o.target.offsetTop >= this._previousScrollData.visibleEntryTop;
|
|
if (s && t) {
|
|
if (i(o),
|
|
!n)
|
|
return
|
|
} else
|
|
s || t || i(o)
|
|
}
|
|
}
|
|
_initializeTargetsAndObservables() {
|
|
this._targetLinks = new Map,
|
|
this._observableSections = new Map;
|
|
const t = z.find(pn, this._config.target);
|
|
for (const e of t) {
|
|
if (!e.hash || r(e))
|
|
continue;
|
|
const t = z.findOne(e.hash, this._element);
|
|
o(t) && (this._targetLinks.set(e.hash, e),
|
|
this._observableSections.set(e.hash, t))
|
|
}
|
|
}
|
|
_process(t) {
|
|
this._activeTarget !== t && (this._clearActiveClass(this._config.target),
|
|
this._activeTarget = t,
|
|
t.classList.add(fn),
|
|
this._activateParents(t),
|
|
I.trigger(this._element, "activate.bs.scrollspy", {
|
|
relatedTarget: t
|
|
}))
|
|
}
|
|
_activateParents(t) {
|
|
if (t.classList.contains("dropdown-item"))
|
|
z.findOne(".dropdown-toggle", t.closest(".dropdown")).classList.add(fn);
|
|
else
|
|
for (const e of z.parents(t, ".nav, .list-group"))
|
|
for (const t of z.prev(e, ".nav-link, .nav-item > .nav-link, .list-group-item"))
|
|
t.classList.add(fn)
|
|
}
|
|
_clearActiveClass(t) {
|
|
t.classList.remove(fn);
|
|
const e = z.find("[href].active", t);
|
|
for (const t of e)
|
|
t.classList.remove(fn)
|
|
}
|
|
static jQueryInterface(t) {
|
|
return this.each((function() {
|
|
const e = _n.getOrCreateInstance(this, t);
|
|
if ("string" == typeof t) {
|
|
if (void 0 === e[t] || t.startsWith("_") || "constructor" === t)
|
|
throw new TypeError(`No method named "${t}"`);
|
|
e[t]()
|
|
}
|
|
}
|
|
))
|
|
}
|
|
}
|
|
I.on(window, "load.bs.scrollspy.data-api", ( () => {
|
|
for (const t of z.find('[data-bs-spy="scroll"]'))
|
|
_n.getOrCreateInstance(t)
|
|
}
|
|
)),
|
|
f(_n);
|
|
const bn = "ArrowLeft"
|
|
, vn = "ArrowRight"
|
|
, yn = "ArrowUp"
|
|
, wn = "ArrowDown"
|
|
, An = "active"
|
|
, En = "fade"
|
|
, Tn = "show"
|
|
, Cn = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]'
|
|
, On = `.nav-link:not(.dropdown-toggle), .list-group-item:not(.dropdown-toggle), [role="tab"]:not(.dropdown-toggle), ${Cn}`;
|
|
class xn extends W {
|
|
constructor(t) {
|
|
super(t),
|
|
this._parent = this._element.closest('.list-group, .nav, [role="tablist"]'),
|
|
this._parent && (this._setInitialAttributes(this._parent, this._getChildren()),
|
|
I.on(this._element, "keydown.bs.tab", (t => this._keydown(t))))
|
|
}
|
|
static get NAME() {
|
|
return "tab"
|
|
}
|
|
show() {
|
|
const t = this._element;
|
|
if (this._elemIsActive(t))
|
|
return;
|
|
const e = this._getActiveElem()
|
|
, i = e ? I.trigger(e, "hide.bs.tab", {
|
|
relatedTarget: t
|
|
}) : null;
|
|
I.trigger(t, "show.bs.tab", {
|
|
relatedTarget: e
|
|
}).defaultPrevented || i && i.defaultPrevented || (this._deactivate(e, t),
|
|
this._activate(t, e))
|
|
}
|
|
_activate(t, e) {
|
|
t && (t.classList.add(An),
|
|
this._activate(z.getElementFromSelector(t)),
|
|
this._queueCallback(( () => {
|
|
"tab" === t.getAttribute("role") ? (t.removeAttribute("tabindex"),
|
|
t.setAttribute("aria-selected", !0),
|
|
this._toggleDropDown(t, !0),
|
|
I.trigger(t, "shown.bs.tab", {
|
|
relatedTarget: e
|
|
})) : t.classList.add(Tn)
|
|
}
|
|
), t, t.classList.contains(En)))
|
|
}
|
|
_deactivate(t, e) {
|
|
t && (t.classList.remove(An),
|
|
t.blur(),
|
|
this._deactivate(z.getElementFromSelector(t)),
|
|
this._queueCallback(( () => {
|
|
"tab" === t.getAttribute("role") ? (t.setAttribute("aria-selected", !1),
|
|
t.setAttribute("tabindex", "-1"),
|
|
this._toggleDropDown(t, !1),
|
|
I.trigger(t, "hidden.bs.tab", {
|
|
relatedTarget: e
|
|
})) : t.classList.remove(Tn)
|
|
}
|
|
), t, t.classList.contains(En)))
|
|
}
|
|
_keydown(t) {
|
|
if (![bn, vn, yn, wn].includes(t.key))
|
|
return;
|
|
t.stopPropagation(),
|
|
t.preventDefault();
|
|
const e = [vn, wn].includes(t.key)
|
|
, i = g(this._getChildren().filter((t => !r(t))), t.target, e, !0);
|
|
i && (i.focus({
|
|
preventScroll: !0
|
|
}),
|
|
xn.getOrCreateInstance(i).show())
|
|
}
|
|
_getChildren() {
|
|
return z.find(On, this._parent)
|
|
}
|
|
_getActiveElem() {
|
|
return this._getChildren().find((t => this._elemIsActive(t))) || null
|
|
}
|
|
_setInitialAttributes(t, e) {
|
|
this._setAttributeIfNotExists(t, "role", "tablist");
|
|
for (const t of e)
|
|
this._setInitialAttributesOnChild(t)
|
|
}
|
|
_setInitialAttributesOnChild(t) {
|
|
t = this._getInnerElement(t);
|
|
const e = this._elemIsActive(t)
|
|
, i = this._getOuterElement(t);
|
|
t.setAttribute("aria-selected", e),
|
|
i !== t && this._setAttributeIfNotExists(i, "role", "presentation"),
|
|
e || t.setAttribute("tabindex", "-1"),
|
|
this._setAttributeIfNotExists(t, "role", "tab"),
|
|
this._setInitialAttributesOnTargetPanel(t)
|
|
}
|
|
_setInitialAttributesOnTargetPanel(t) {
|
|
const e = z.getElementFromSelector(t);
|
|
e && (this._setAttributeIfNotExists(e, "role", "tabpanel"),
|
|
t.id && this._setAttributeIfNotExists(e, "aria-labelledby", `#${t.id}`))
|
|
}
|
|
_toggleDropDown(t, e) {
|
|
const i = this._getOuterElement(t);
|
|
if (!i.classList.contains("dropdown"))
|
|
return;
|
|
const n = (t, n) => {
|
|
const s = z.findOne(t, i);
|
|
s && s.classList.toggle(n, e)
|
|
}
|
|
;
|
|
n(".dropdown-toggle", An),
|
|
n(".dropdown-menu", Tn),
|
|
i.setAttribute("aria-expanded", e)
|
|
}
|
|
_setAttributeIfNotExists(t, e, i) {
|
|
t.hasAttribute(e) || t.setAttribute(e, i)
|
|
}
|
|
_elemIsActive(t) {
|
|
return t.classList.contains(An)
|
|
}
|
|
_getInnerElement(t) {
|
|
return t.matches(On) ? t : z.findOne(On, t)
|
|
}
|
|
_getOuterElement(t) {
|
|
return t.closest(".nav-item, .list-group-item") || t
|
|
}
|
|
static jQueryInterface(t) {
|
|
return this.each((function() {
|
|
const e = xn.getOrCreateInstance(this);
|
|
if ("string" == typeof t) {
|
|
if (void 0 === e[t] || t.startsWith("_") || "constructor" === t)
|
|
throw new TypeError(`No method named "${t}"`);
|
|
e[t]()
|
|
}
|
|
}
|
|
))
|
|
}
|
|
}
|
|
I.on(document, "click.bs.tab", Cn, (function(t) {
|
|
["A", "AREA"].includes(this.tagName) && t.preventDefault(),
|
|
r(this) || xn.getOrCreateInstance(this).show()
|
|
}
|
|
)),
|
|
I.on(window, "load.bs.tab", ( () => {
|
|
for (const t of z.find('.active[data-bs-toggle="tab"], .active[data-bs-toggle="pill"], .active[data-bs-toggle="list"]'))
|
|
xn.getOrCreateInstance(t)
|
|
}
|
|
)),
|
|
f(xn);
|
|
const kn = "hide"
|
|
, Ln = "show"
|
|
, Sn = "showing"
|
|
, Dn = {
|
|
animation: "boolean",
|
|
autohide: "boolean",
|
|
delay: "number"
|
|
}
|
|
, In = {
|
|
animation: !0,
|
|
autohide: !0,
|
|
delay: 5e3
|
|
};
|
|
class Nn extends W {
|
|
constructor(t, e) {
|
|
super(t, e),
|
|
this._timeout = null,
|
|
this._hasMouseInteraction = !1,
|
|
this._hasKeyboardInteraction = !1,
|
|
this._setListeners()
|
|
}
|
|
static get Default() {
|
|
return In
|
|
}
|
|
static get DefaultType() {
|
|
return Dn
|
|
}
|
|
static get NAME() {
|
|
return "toast"
|
|
}
|
|
show() {
|
|
I.trigger(this._element, "show.bs.toast").defaultPrevented || (this._clearTimeout(),
|
|
this._config.animation && this._element.classList.add("fade"),
|
|
this._element.classList.remove(kn),
|
|
c(this._element),
|
|
this._element.classList.add(Ln, Sn),
|
|
this._queueCallback(( () => {
|
|
this._element.classList.remove(Sn),
|
|
I.trigger(this._element, "shown.bs.toast"),
|
|
this._maybeScheduleHide()
|
|
}
|
|
), this._element, this._config.animation))
|
|
}
|
|
hide() {
|
|
this.isShown() && (I.trigger(this._element, "hide.bs.toast").defaultPrevented || (this._element.classList.add(Sn),
|
|
this._queueCallback(( () => {
|
|
this._element.classList.add(kn),
|
|
this._element.classList.remove(Sn, Ln),
|
|
I.trigger(this._element, "hidden.bs.toast")
|
|
}
|
|
), this._element, this._config.animation)))
|
|
}
|
|
dispose() {
|
|
this._clearTimeout(),
|
|
this.isShown() && this._element.classList.remove(Ln),
|
|
super.dispose()
|
|
}
|
|
isShown() {
|
|
return this._element.classList.contains(Ln)
|
|
}
|
|
_maybeScheduleHide() {
|
|
this._config.autohide && (this._hasMouseInteraction || this._hasKeyboardInteraction || (this._timeout = setTimeout(( () => {
|
|
this.hide()
|
|
}
|
|
), this._config.delay)))
|
|
}
|
|
_onInteraction(t, e) {
|
|
switch (t.type) {
|
|
case "mouseover":
|
|
case "mouseout":
|
|
this._hasMouseInteraction = e;
|
|
break;
|
|
case "focusin":
|
|
case "focusout":
|
|
this._hasKeyboardInteraction = e
|
|
}
|
|
if (e)
|
|
return void this._clearTimeout();
|
|
const i = t.relatedTarget;
|
|
this._element === i || this._element.contains(i) || this._maybeScheduleHide()
|
|
}
|
|
_setListeners() {
|
|
I.on(this._element, "mouseover.bs.toast", (t => this._onInteraction(t, !0))),
|
|
I.on(this._element, "mouseout.bs.toast", (t => this._onInteraction(t, !1))),
|
|
I.on(this._element, "focusin.bs.toast", (t => this._onInteraction(t, !0))),
|
|
I.on(this._element, "focusout.bs.toast", (t => this._onInteraction(t, !1)))
|
|
}
|
|
_clearTimeout() {
|
|
clearTimeout(this._timeout),
|
|
this._timeout = null
|
|
}
|
|
static jQueryInterface(t) {
|
|
return this.each((function() {
|
|
const e = Nn.getOrCreateInstance(this, t);
|
|
if ("string" == typeof t) {
|
|
if (void 0 === e[t])
|
|
throw new TypeError(`No method named "${t}"`);
|
|
e[t](this)
|
|
}
|
|
}
|
|
))
|
|
}
|
|
}
|
|
return R(Nn),
|
|
f(Nn),
|
|
{
|
|
Alert: q,
|
|
Button: K,
|
|
Carousel: rt,
|
|
Collapse: ft,
|
|
Dropdown: ci,
|
|
Modal: Ii,
|
|
Offcanvas: Bi,
|
|
Popover: dn,
|
|
ScrollSpy: _n,
|
|
Tab: xn,
|
|
Toast: Nn,
|
|
Tooltip: ln
|
|
}
|
|
}
|
|
));
|
|
//# sourceMappingURL=bootstrap.bundle.min.js.map
|