mdb-ui-kit
Version:
Bootstrap 5 UI KIT - 700+ components, plain JavaScript, MIT license, simple installation.
1,633 lines • 259 kB
JavaScript
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
const mapData = (() => {
const storeData = {};
let id = 1;
return {
set(element2, key, data) {
if (typeof element2[key] === "undefined") {
element2[key] = {
key,
id
};
id++;
}
storeData[element2[key].id] = data;
},
get(element2, key) {
if (!element2 || typeof element2[key] === "undefined") {
return null;
}
const keyProperties = element2[key];
if (keyProperties.key === key) {
return storeData[keyProperties.id];
}
return null;
},
delete(element2, key) {
if (typeof element2[key] === "undefined") {
return;
}
const keyProperties = element2[key];
if (keyProperties.key === key) {
delete storeData[keyProperties.id];
delete element2[key];
}
}
};
})();
const Data$1 = {
setData(instance, key, data) {
mapData.set(instance, key, data);
},
getData(instance, key) {
return mapData.get(instance, key);
},
removeData(instance, key) {
mapData.delete(instance, key);
}
};
const toType$1 = (obj) => {
if (obj === null || obj === void 0) {
return `${obj}`;
}
return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
};
const getSelector$1 = (element2) => {
let selector = element2.getAttribute("data-mdb-target");
if (!selector || selector === "#") {
const hrefAttr = element2.getAttribute("href");
selector = hrefAttr && hrefAttr !== "#" ? hrefAttr.trim() : null;
}
return selector;
};
const getSelectorFromElement = (element2) => {
const selector = getSelector$1(element2);
if (selector) {
return document.querySelector(selector) ? selector : null;
}
return null;
};
const getElementFromSelector = (element2) => {
const selector = getSelector$1(element2);
return selector ? document.querySelector(selector) : null;
};
const isElement$2 = (obj) => {
if (!obj || typeof obj !== "object") {
return false;
}
if (typeof obj.jquery !== "undefined") {
obj = obj[0];
}
return typeof obj.nodeType !== "undefined";
};
const getElement$1 = (obj) => {
if (isElement$2(obj)) {
return obj.jquery ? obj[0] : obj;
}
if (typeof obj === "string" && obj.length > 0) {
return document.querySelector(obj);
}
return null;
};
const typeCheckConfig = (componentName, config, configTypes) => {
Object.keys(configTypes).forEach((property) => {
const expectedTypes = configTypes[property];
const value = config[property];
const valueType = value && isElement$2(value) ? "element" : toType$1(value);
if (!new RegExp(expectedTypes).test(valueType)) {
throw new Error(
`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`
);
}
});
};
const isVisible$1 = (element2) => {
if (!element2) {
return false;
}
if (element2.style && element2.parentNode && element2.parentNode.style) {
const elementStyle = getComputedStyle(element2);
const parentNodeStyle = getComputedStyle(element2.parentNode);
return elementStyle.display !== "none" && parentNodeStyle.display !== "none" && elementStyle.visibility !== "hidden";
}
return false;
};
const isDisabled$1 = (element2) => {
if (!element2 || element2.nodeType !== Node.ELEMENT_NODE) {
return true;
}
if (element2.classList.contains("disabled")) {
return true;
}
if (typeof element2.disabled !== "undefined") {
return element2.disabled;
}
return element2.hasAttribute("disabled") && element2.getAttribute("disabled") !== "false";
};
const getjQuery$1 = () => {
const { jQuery } = window;
if (jQuery && !document.body.hasAttribute("data-mdb-no-jquery")) {
return jQuery;
}
return null;
};
const onDOMContentLoaded = (callback) => {
if (document.readyState === "loading") {
document.addEventListener("DOMContentLoaded", callback);
} else {
callback();
}
};
document.documentElement.dir === "rtl";
const element = (tag) => {
return document.createElement(tag);
};
const defineJQueryPlugin = (plugin) => {
onDOMContentLoaded(() => {
const $2 = getjQuery$1();
if ($2) {
const name = plugin.NAME;
const JQUERY_NO_CONFLICT = $2.fn[name];
$2.fn[name] = plugin.jQueryInterface;
$2.fn[name].Constructor = plugin;
$2.fn[name].noConflict = () => {
$2.fn[name] = JQUERY_NO_CONFLICT;
return plugin.jQueryInterface;
};
}
});
};
const $ = getjQuery$1();
const namespaceRegex$1 = /[^.]*(?=\..*)\.|.*/;
const stripNameRegex$1 = /\..*/;
const stripUidRegex$1 = /::\d+$/;
const eventRegistry$1 = {};
let uidEvent$1 = 1;
const customEvents$1 = {
mouseenter: "mouseover",
mouseleave: "mouseout"
};
const nativeEvents$1 = [
"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 getUidEvent(element2, uid) {
return uid && `${uid}::${uidEvent$1++}` || element2.uidEvent || uidEvent$1++;
}
function getEvent(element2) {
const uid = getUidEvent(element2);
element2.uidEvent = uid;
eventRegistry$1[uid] = eventRegistry$1[uid] || {};
return eventRegistry$1[uid];
}
function bootstrapHandler$1(element2, fn2) {
return function handler(event) {
event.delegateTarget = element2;
if (handler.oneOff) {
EventHandler$1.off(element2, event.type, fn2);
}
return fn2.apply(element2, [event]);
};
}
function bootstrapDelegationHandler$1(element2, selector, fn2) {
return function handler(event) {
const domElements = element2.querySelectorAll(selector);
for (let { target } = event; target && target !== this; target = target.parentNode) {
for (let i = domElements.length; i--; "") {
if (domElements[i] === target) {
event.delegateTarget = target;
if (handler.oneOff) {
EventHandler$1.off(element2, event.type, fn2);
}
return fn2.apply(target, [event]);
}
}
}
return null;
};
}
function findHandler$1(events, handler, delegationSelector = null) {
const uidEventList = Object.keys(events);
for (let i = 0, len = uidEventList.length; i < len; i++) {
const event = events[uidEventList[i]];
if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {
return event;
}
}
return null;
}
function normalizeParams(originalTypeEvent, handler, delegationFn) {
const delegation = typeof handler === "string";
const originalHandler = delegation ? delegationFn : handler;
let typeEvent = originalTypeEvent.replace(stripNameRegex$1, "");
const custom = customEvents$1[typeEvent];
if (custom) {
typeEvent = custom;
}
const isNative = nativeEvents$1.indexOf(typeEvent) > -1;
if (!isNative) {
typeEvent = originalTypeEvent;
}
return [delegation, originalHandler, typeEvent];
}
function addHandler$1(element2, originalTypeEvent, handler, delegationFn, oneOff) {
if (typeof originalTypeEvent !== "string" || !element2) {
return;
}
if (!handler) {
handler = delegationFn;
delegationFn = null;
}
const [delegation, originalHandler, typeEvent] = normalizeParams(
originalTypeEvent,
handler,
delegationFn
);
const events = getEvent(element2);
const handlers = events[typeEvent] || (events[typeEvent] = {});
const previousFn = findHandler$1(handlers, originalHandler, delegation ? handler : null);
if (previousFn) {
previousFn.oneOff = previousFn.oneOff && oneOff;
return;
}
const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex$1, ""));
const fn2 = delegation ? bootstrapDelegationHandler$1(element2, handler, delegationFn) : bootstrapHandler$1(element2, handler);
fn2.delegationSelector = delegation ? handler : null;
fn2.originalHandler = originalHandler;
fn2.oneOff = oneOff;
fn2.uidEvent = uid;
handlers[uid] = fn2;
element2.addEventListener(typeEvent, fn2, delegation);
}
function removeHandler$1(element2, events, typeEvent, handler, delegationSelector) {
const fn2 = findHandler$1(events[typeEvent], handler, delegationSelector);
if (!fn2) {
return;
}
element2.removeEventListener(typeEvent, fn2, Boolean(delegationSelector));
delete events[typeEvent][fn2.uidEvent];
}
function removeNamespacedHandlers$1(element2, events, typeEvent, namespace) {
const storeElementEvent = events[typeEvent] || {};
Object.keys(storeElementEvent).forEach((handlerKey) => {
if (handlerKey.indexOf(namespace) > -1) {
const event = storeElementEvent[handlerKey];
removeHandler$1(element2, events, typeEvent, event.originalHandler, event.delegationSelector);
}
});
}
const EventHandler$1 = {
on(element2, event, handler, delegationFn) {
addHandler$1(element2, event, handler, delegationFn, false);
},
one(element2, event, handler, delegationFn) {
addHandler$1(element2, event, handler, delegationFn, true);
},
extend(element2, events, componentName) {
events.forEach((event) => {
EventHandler$1.on(element2, `${event.name}.bs.${componentName}`, (e) => {
const eventParameters = {};
if (event.parametersToCopy) {
event.parametersToCopy.forEach((param) => {
eventParameters[param] = e[param];
});
}
const mdbEvent = EventHandler$1.trigger(
element2,
`${event.name}.mdb.${componentName}`,
eventParameters
);
if (mdbEvent.defaultPrevented) {
e.preventDefault();
}
});
});
},
off(element2, originalTypeEvent, handler, delegationFn) {
if (typeof originalTypeEvent !== "string" || !element2) {
return;
}
const [delegation, originalHandler, typeEvent] = normalizeParams(
originalTypeEvent,
handler,
delegationFn
);
const inNamespace = typeEvent !== originalTypeEvent;
const events = getEvent(element2);
const isNamespace = originalTypeEvent.charAt(0) === ".";
if (typeof originalHandler !== "undefined") {
if (!events || !events[typeEvent]) {
return;
}
removeHandler$1(element2, events, typeEvent, originalHandler, delegation ? handler : null);
return;
}
if (isNamespace) {
Object.keys(events).forEach((elementEvent) => {
removeNamespacedHandlers$1(element2, events, elementEvent, originalTypeEvent.slice(1));
});
}
const storeElementEvent = events[typeEvent] || {};
Object.keys(storeElementEvent).forEach((keyHandlers) => {
const handlerKey = keyHandlers.replace(stripUidRegex$1, "");
if (!inNamespace || originalTypeEvent.indexOf(handlerKey) > -1) {
const event = storeElementEvent[keyHandlers];
removeHandler$1(element2, events, typeEvent, event.originalHandler, event.delegationSelector);
}
});
},
trigger(element2, event, args) {
if (typeof event !== "string" || !element2) {
return null;
}
const typeEvent = event.replace(stripNameRegex$1, "");
const inNamespace = event !== typeEvent;
const isNative = nativeEvents$1.indexOf(typeEvent) > -1;
let jQueryEvent;
let bubbles = true;
let nativeDispatch = true;
let defaultPrevented = false;
let evt = null;
if (inNamespace && $) {
jQueryEvent = $.Event(event, args);
$(element2).trigger(jQueryEvent);
bubbles = !jQueryEvent.isPropagationStopped();
nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
defaultPrevented = jQueryEvent.isDefaultPrevented();
}
if (isNative) {
evt = document.createEvent("HTMLEvents");
evt.initEvent(typeEvent, bubbles, true);
} else {
evt = new CustomEvent(event, {
bubbles,
cancelable: true
});
}
if (typeof args !== "undefined") {
Object.keys(args).forEach((key) => {
Object.defineProperty(evt, key, {
get() {
return args[key];
}
});
});
}
if (defaultPrevented) {
evt.preventDefault();
}
if (nativeDispatch) {
element2.dispatchEvent(evt);
}
if (evt.defaultPrevented && typeof jQueryEvent !== "undefined") {
jQueryEvent.preventDefault();
}
return evt;
}
};
function normalizeData$1(val) {
if (val === "true") {
return true;
}
if (val === "false") {
return false;
}
if (val === Number(val).toString()) {
return Number(val);
}
if (val === "" || val === "null") {
return null;
}
return val;
}
function normalizeDataKey$1(key) {
return key.replace(/[A-Z]/g, (chr) => `-${chr.toLowerCase()}`);
}
const Manipulator$1 = {
setDataAttribute(element2, key, value) {
element2.setAttribute(`data-mdb-${normalizeDataKey$1(key)}`, value);
},
removeDataAttribute(element2, key) {
element2.removeAttribute(`data-mdb-${normalizeDataKey$1(key)}`);
},
getDataAttributes(element2) {
if (!element2) {
return {};
}
const attributes = {
...element2.dataset
};
Object.keys(attributes).filter((key) => key.startsWith("mdb")).forEach((key) => {
let pureKey = key.replace(/^mdb/, "");
pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
attributes[pureKey] = normalizeData$1(attributes[key]);
});
return attributes;
},
getDataAttribute(element2, key) {
return normalizeData$1(element2.getAttribute(`data-mdb-${normalizeDataKey$1(key)}`));
},
offset(element2) {
const rect = element2.getBoundingClientRect();
return {
top: rect.top + document.body.scrollTop,
left: rect.left + document.body.scrollLeft
};
},
position(element2) {
return {
top: element2.offsetTop,
left: element2.offsetLeft
};
},
style(element2, style) {
Object.assign(element2.style, style);
},
toggleClass(element2, className) {
if (!element2) {
return;
}
if (element2.classList.contains(className)) {
element2.classList.remove(className);
} else {
element2.classList.add(className);
}
},
addClass(element2, className) {
if (element2.classList.contains(className))
return;
element2.classList.add(className);
},
addStyle(element2, style) {
Object.keys(style).forEach((property) => {
element2.style[property] = style[property];
});
},
removeClass(element2, className) {
if (!element2.classList.contains(className))
return;
element2.classList.remove(className);
},
hasClass(element2, className) {
return element2.classList.contains(className);
}
};
const NODE_TEXT = 3;
const SelectorEngine$1 = {
closest(element2, selector) {
return element2.closest(selector);
},
matches(element2, selector) {
return element2.matches(selector);
},
find(selector, element2 = document.documentElement) {
return [].concat(...Element.prototype.querySelectorAll.call(element2, selector));
},
findOne(selector, element2 = document.documentElement) {
return Element.prototype.querySelector.call(element2, selector);
},
children(element2, selector) {
const children = [].concat(...element2.children);
return children.filter((child) => child.matches(selector));
},
parents(element2, selector) {
const parents = [];
let ancestor = element2.parentNode;
while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
if (this.matches(ancestor, selector)) {
parents.push(ancestor);
}
ancestor = ancestor.parentNode;
}
return parents;
},
prev(element2, selector) {
let previous = element2.previousElementSibling;
while (previous) {
if (previous.matches(selector)) {
return [previous];
}
previous = previous.previousElementSibling;
}
return [];
},
next(element2, selector) {
let next = element2.nextElementSibling;
while (next) {
if (this.matches(next, selector)) {
return [next];
}
next = next.nextElementSibling;
}
return [];
}
};
const elementMap = /* @__PURE__ */ new Map();
const Data = {
set(element2, key, instance) {
if (!elementMap.has(element2)) {
elementMap.set(element2, /* @__PURE__ */ new Map());
}
const instanceMap = elementMap.get(element2);
if (!instanceMap.has(key) && instanceMap.size !== 0) {
console.error(
`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`
);
return;
}
instanceMap.set(key, instance);
},
get(element2, key) {
if (elementMap.has(element2)) {
return elementMap.get(element2).get(key) || null;
}
return null;
},
remove(element2, key) {
if (!elementMap.has(element2)) {
return;
}
const instanceMap = elementMap.get(element2);
instanceMap.delete(key);
if (instanceMap.size === 0) {
elementMap.delete(element2);
}
}
};
const MAX_UID = 1e6;
const MILLISECONDS_MULTIPLIER = 1e3;
const TRANSITION_END = "transitionend";
const parseSelector = (selector) => {
if (selector && window.CSS && window.CSS.escape) {
selector = selector.replace(/#([^\s"#']+)/g, (match, id) => `#${CSS.escape(id)}`);
}
return selector;
};
const toType = (object) => {
if (object === null || object === void 0) {
return `${object}`;
}
return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase();
};
const getUID = (prefix) => {
do {
prefix += Math.floor(Math.random() * MAX_UID);
} while (document.getElementById(prefix));
return prefix;
};
const getTransitionDurationFromElement = (element2) => {
if (!element2) {
return 0;
}
let { transitionDuration, transitionDelay } = window.getComputedStyle(element2);
const floatTransitionDuration = Number.parseFloat(transitionDuration);
const floatTransitionDelay = Number.parseFloat(transitionDelay);
if (!floatTransitionDuration && !floatTransitionDelay) {
return 0;
}
transitionDuration = transitionDuration.split(",")[0];
transitionDelay = transitionDelay.split(",")[0];
return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
};
const triggerTransitionEnd = (element2) => {
element2.dispatchEvent(new Event(TRANSITION_END));
};
const isElement$1 = (object) => {
if (!object || typeof object !== "object") {
return false;
}
if (typeof object.jquery !== "undefined") {
object = object[0];
}
return typeof object.nodeType !== "undefined";
};
const getElement = (object) => {
if (isElement$1(object)) {
return object.jquery ? object[0] : object;
}
if (typeof object === "string" && object.length > 0) {
return document.querySelector(parseSelector(object));
}
return null;
};
const isVisible = (element2) => {
if (!isElement$1(element2) || element2.getClientRects().length === 0) {
return false;
}
const elementIsVisible = getComputedStyle(element2).getPropertyValue("visibility") === "visible";
const closedDetails = element2.closest("details:not([open])");
if (!closedDetails) {
return elementIsVisible;
}
if (closedDetails !== element2) {
const summary = element2.closest("summary");
if (summary && summary.parentNode !== closedDetails) {
return false;
}
if (summary === null) {
return false;
}
}
return elementIsVisible;
};
const isDisabled = (element2) => {
if (!element2 || element2.nodeType !== Node.ELEMENT_NODE) {
return true;
}
if (element2.classList.contains("disabled")) {
return true;
}
if (typeof element2.disabled !== "undefined") {
return element2.disabled;
}
return element2.hasAttribute("disabled") && element2.getAttribute("disabled") !== "false";
};
const findShadowRoot = (element2) => {
if (!document.documentElement.attachShadow) {
return null;
}
if (typeof element2.getRootNode === "function") {
const root = element2.getRootNode();
return root instanceof ShadowRoot ? root : null;
}
if (element2 instanceof ShadowRoot) {
return element2;
}
if (!element2.parentNode) {
return null;
}
return findShadowRoot(element2.parentNode);
};
const noop = () => {
};
const reflow = (element2) => {
element2.offsetHeight;
};
const getjQuery = () => {
if (window.jQuery && !document.body.hasAttribute("data-mdb-no-jquery")) {
return window.jQuery;
}
return null;
};
const isRTL = () => document.documentElement.dir === "rtl";
const execute = (possibleCallback, args = [], defaultValue = possibleCallback) => {
return typeof possibleCallback === "function" ? possibleCallback(...args) : defaultValue;
};
const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
if (!waitForTransition) {
execute(callback);
return;
}
const durationPadding = 5;
const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
let called = false;
const handler = ({ target }) => {
if (target !== transitionElement) {
return;
}
called = true;
transitionElement.removeEventListener(TRANSITION_END, handler);
execute(callback);
};
transitionElement.addEventListener(TRANSITION_END, handler);
setTimeout(() => {
if (!called) {
triggerTransitionEnd(transitionElement);
}
}, emulatedDuration);
};
const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
const listLength = list.length;
let index = list.indexOf(activeElement);
if (index === -1) {
return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];
}
index += shouldGetNext ? 1 : -1;
if (isCycleAllowed) {
index = (index + listLength) % listLength;
}
return list[Math.max(0, Math.min(index, listLength - 1))];
};
const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
const stripNameRegex = /\..*/;
const stripUidRegex = /::\d+$/;
const eventRegistry = {};
let uidEvent = 1;
const customEvents = {
mouseenter: "mouseover",
mouseleave: "mouseout"
};
const nativeEvents = /* @__PURE__ */ 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 makeEventUid(element2, uid) {
return uid && `${uid}::${uidEvent++}` || element2.uidEvent || uidEvent++;
}
function getElementEvents(element2) {
const uid = makeEventUid(element2);
element2.uidEvent = uid;
eventRegistry[uid] = eventRegistry[uid] || {};
return eventRegistry[uid];
}
function bootstrapHandler(element2, fn2) {
return function handler(event) {
hydrateObj(event, { delegateTarget: element2 });
if (handler.oneOff) {
EventHandler.off(element2, event.type, fn2);
}
return fn2.apply(element2, [event]);
};
}
function bootstrapDelegationHandler(element2, selector, fn2) {
return function handler(event) {
const domElements = element2.querySelectorAll(selector);
for (let { target } = event; target && target !== this; target = target.parentNode) {
for (const domElement of domElements) {
if (domElement !== target) {
continue;
}
hydrateObj(event, { delegateTarget: target });
if (handler.oneOff) {
EventHandler.off(element2, event.type, selector, fn2);
}
return fn2.apply(target, [event]);
}
}
};
}
function findHandler(events, callable, delegationSelector = null) {
return Object.values(events).find(
(event) => event.callable === callable && event.delegationSelector === delegationSelector
);
}
function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
const isDelegated = typeof handler === "string";
const callable = isDelegated ? delegationFunction : handler || delegationFunction;
let typeEvent = getTypeEvent(originalTypeEvent);
if (!nativeEvents.has(typeEvent)) {
typeEvent = originalTypeEvent;
}
return [isDelegated, callable, typeEvent];
}
function addHandler(element2, originalTypeEvent, handler, delegationFunction, oneOff) {
if (typeof originalTypeEvent !== "string" || !element2) {
return;
}
let [isDelegated, callable, typeEvent] = normalizeParameters(
originalTypeEvent,
handler,
delegationFunction
);
if (originalTypeEvent in customEvents) {
const wrapFunction = (fn3) => {
return function(event) {
if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
return fn3.call(this, event);
}
};
};
callable = wrapFunction(callable);
}
const events = getElementEvents(element2);
const handlers = events[typeEvent] || (events[typeEvent] = {});
const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
if (previousFunction) {
previousFunction.oneOff = previousFunction.oneOff && oneOff;
return;
}
const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ""));
const fn2 = isDelegated ? bootstrapDelegationHandler(element2, handler, callable) : bootstrapHandler(element2, callable);
fn2.delegationSelector = isDelegated ? handler : null;
fn2.callable = callable;
fn2.oneOff = oneOff;
fn2.uidEvent = uid;
handlers[uid] = fn2;
element2.addEventListener(typeEvent, fn2, isDelegated);
}
function removeHandler(element2, events, typeEvent, handler, delegationSelector) {
const fn2 = findHandler(events[typeEvent], handler, delegationSelector);
if (!fn2) {
return;
}
element2.removeEventListener(typeEvent, fn2, Boolean(delegationSelector));
delete events[typeEvent][fn2.uidEvent];
}
function removeNamespacedHandlers(element2, events, typeEvent, namespace) {
const storeElementEvent = events[typeEvent] || {};
for (const [handlerKey, event] of Object.entries(storeElementEvent)) {
if (handlerKey.includes(namespace)) {
removeHandler(element2, events, typeEvent, event.callable, event.delegationSelector);
}
}
}
function getTypeEvent(event) {
event = event.replace(stripNameRegex, "");
return customEvents[event] || event;
}
const EventHandler = {
on(element2, event, handler, delegationFunction) {
addHandler(element2, event, handler, delegationFunction, false);
},
one(element2, event, handler, delegationFunction) {
addHandler(element2, event, handler, delegationFunction, true);
},
off(element2, originalTypeEvent, handler, delegationFunction) {
if (typeof originalTypeEvent !== "string" || !element2) {
return;
}
const [isDelegated, callable, typeEvent] = normalizeParameters(
originalTypeEvent,
handler,
delegationFunction
);
const inNamespace = typeEvent !== originalTypeEvent;
const events = getElementEvents(element2);
const storeElementEvent = events[typeEvent] || {};
const isNamespace = originalTypeEvent.startsWith(".");
if (typeof callable !== "undefined") {
if (!Object.keys(storeElementEvent).length) {
return;
}
removeHandler(element2, events, typeEvent, callable, isDelegated ? handler : null);
return;
}
if (isNamespace) {
for (const elementEvent of Object.keys(events)) {
removeNamespacedHandlers(element2, events, elementEvent, originalTypeEvent.slice(1));
}
}
for (const [keyHandlers, event] of Object.entries(storeElementEvent)) {
const handlerKey = keyHandlers.replace(stripUidRegex, "");
if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
removeHandler(element2, events, typeEvent, event.callable, event.delegationSelector);
}
}
},
trigger(element2, event, args) {
if (typeof event !== "string" || !element2) {
return null;
}
const $2 = getjQuery();
const typeEvent = getTypeEvent(event);
const inNamespace = event !== typeEvent;
let jQueryEvent = null;
let bubbles = true;
let nativeDispatch = true;
let defaultPrevented = false;
if (inNamespace && $2) {
jQueryEvent = $2.Event(event, args);
$2(element2).trigger(jQueryEvent);
bubbles = !jQueryEvent.isPropagationStopped();
nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
defaultPrevented = jQueryEvent.isDefaultPrevented();
}
const evt = hydrateObj(new Event(event, { bubbles, cancelable: true }), args);
if (defaultPrevented) {
evt.preventDefault();
}
if (nativeDispatch) {
element2.dispatchEvent(evt);
}
if (evt.defaultPrevented && jQueryEvent) {
jQueryEvent.preventDefault();
}
return evt;
}
};
function hydrateObj(obj, meta = {}) {
for (const [key, value] of Object.entries(meta)) {
try {
obj[key] = value;
} catch {
Object.defineProperty(obj, key, {
configurable: true,
get() {
return value;
}
});
}
}
return obj;
}
function normalizeData(value) {
if (value === "true") {
return true;
}
if (value === "false") {
return false;
}
if (value === Number(value).toString()) {
return Number(value);
}
if (value === "" || value === "null") {
return null;
}
if (typeof value !== "string") {
return value;
}
try {
return JSON.parse(decodeURIComponent(value));
} catch {
return value;
}
}
function normalizeDataKey(key) {
return key.replace(/[A-Z]/g, (chr) => `-${chr.toLowerCase()}`);
}
const Manipulator = {
setDataAttribute(element2, key, value) {
element2.setAttribute(`data-mdb-${normalizeDataKey(key)}`, value);
},
removeDataAttribute(element2, key) {
element2.removeAttribute(`data-mdb-${normalizeDataKey(key)}`);
},
getDataAttributes(element2) {
if (!element2) {
return {};
}
const attributes = {};
const mdbKeys = Object.keys(element2.dataset).filter(
(key) => key.startsWith("mdb") && !key.startsWith("mdbConfig")
);
for (const key of mdbKeys) {
let pureKey = key.replace(/^mdb/, "");
pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
attributes[pureKey] = normalizeData(element2.dataset[key]);
}
return attributes;
},
getDataAttribute(element2, key) {
return normalizeData(element2.getAttribute(`data-mdb-${normalizeDataKey(key)}`));
}
};
class Config {
// Getters
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(config) {
config = this._mergeConfigObj(config);
config = this._configAfterMerge(config);
this._typeCheckConfig(config);
return config;
}
_configAfterMerge(config) {
return config;
}
_mergeConfigObj(config, element2) {
const jsonConfig = isElement$1(element2) ? Manipulator.getDataAttribute(element2, "config") : {};
return {
...this.constructor.Default,
...typeof jsonConfig === "object" ? jsonConfig : {},
...isElement$1(element2) ? Manipulator.getDataAttributes(element2) : {},
...typeof config === "object" ? config : {}
};
}
_typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
for (const [property, expectedTypes] of Object.entries(configTypes)) {
const value = config[property];
const valueType = isElement$1(value) ? "element" : toType(value);
if (!new RegExp(expectedTypes).test(valueType)) {
throw new TypeError(
`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`
);
}
}
}
}
const VERSION = "5.3.3";
let BaseComponent$1 = class BaseComponent extends Config {
constructor(element2, config) {
super();
element2 = getElement(element2);
if (!element2) {
return;
}
this._element = element2;
this._config = this._getConfig(config);
Data.set(this._element, this.constructor.DATA_KEY, this);
}
// Public
dispose() {
Data.remove(this._element, this.constructor.DATA_KEY);
EventHandler.off(this._element, this.constructor.EVENT_KEY);
for (const propertyName of Object.getOwnPropertyNames(this)) {
this[propertyName] = null;
}
}
_queueCallback(callback, element2, isAnimated = true) {
executeAfterTransition(callback, element2, isAnimated);
}
_getConfig(config) {
config = this._mergeConfigObj(config, this._element);
config = this._configAfterMerge(config);
this._typeCheckConfig(config);
return config;
}
// Static
static getInstance(element2) {
return Data.get(getElement(element2), this.DATA_KEY);
}
static getOrCreateInstance(element2, config = {}) {
return this.getInstance(element2) || new this(element2, typeof config === "object" ? config : null);
}
static get VERSION() {
return VERSION;
}
static get DATA_KEY() {
return `bs.${this.NAME}`;
}
static get EVENT_KEY() {
return `.${this.DATA_KEY}`;
}
static eventName(name) {
return `${name}${this.EVENT_KEY}`;
}
};
const NAME$t = "button";
const CLASS_NAME_ACTIVE$5 = "active";
let Button$1 = class Button extends BaseComponent$1 {
// Getters
static get NAME() {
return NAME$t;
}
// Public
toggle() {
this._element.setAttribute("aria-pressed", this._element.classList.toggle(CLASS_NAME_ACTIVE$5));
}
// Static
static jQueryInterface(config) {
return this.each(function() {
const data = Button.getOrCreateInstance(this);
if (config === "toggle") {
data[config]();
}
});
}
};
const mapComponentsData = (() => {
const componentsData = [];
return {
set(componentName) {
componentsData.push(componentName);
},
get(componentName) {
return componentsData.includes(componentName);
}
};
})();
const InitializedComponents = {
set(componentName) {
mapComponentsData.set(componentName);
},
get(componentName) {
return mapComponentsData.get(componentName);
}
};
const isInitialized = (componentName) => {
return InitializedComponents.get(componentName);
};
const bindCallbackEventsIfNeeded = (component) => {
if (!isInitialized(component.NAME)) {
const manualInit = true;
initComponent(component, manualInit);
}
};
const initComponent = (component, manualInit = false) => {
if (!component || InitializedComponents.get(component.NAME)) {
return;
}
if (!manualInit) {
InitializedComponents.set(component.NAME);
}
const thisComponent = _defaultInitSelectors[component.NAME] || null;
const isToggler = (thisComponent == null ? void 0 : thisComponent.isToggler) || false;
defineJQueryPlugin(component);
if (thisComponent == null ? void 0 : thisComponent.advanced) {
thisComponent.advanced(component, thisComponent == null ? void 0 : thisComponent.selector);
return;
}
if (isToggler) {
thisComponent.callback(component, thisComponent == null ? void 0 : thisComponent.selector);
return;
}
if (manualInit) {
return;
}
SelectorEngine$1.find(thisComponent == null ? void 0 : thisComponent.selector).forEach((element2) => {
let instance = component.getInstance(element2);
if (!instance) {
instance = new component(element2);
if (thisComponent == null ? void 0 : thisComponent.onInit) {
instance[thisComponent.onInit]();
}
}
});
};
let _defaultInitSelectors;
class InitMDB {
constructor(defaultInitSelectors2) {
__publicField(this, "init", (components) => {
components.forEach((component) => initComponent(component));
});
__publicField(this, "initMDB", (components, checkOtherImports = false) => {
const componentList = Object.keys(_defaultInitSelectors).map((element2) => {
const requireAutoInit = Boolean(
document.querySelector(_defaultInitSelectors[element2].selector)
);
if (requireAutoInit) {
const component = components[_defaultInitSelectors[element2].name];
if (!component && !InitializedComponents.get(element2) && checkOtherImports) {
console.warn(
`Please import ${_defaultInitSelectors[element2].name} from "MDB" package and add it to a object parameter inside "initMDB" function`
);
}
return component;
}
return null;
});
this.init(componentList);
});
_defaultInitSelectors = defaultInitSelectors2;
}
}
const NAME$s = "button";
const DATA_KEY$g = `mdb.${NAME$s}`;
const EVENT_KEY$e = `.${DATA_KEY$g}`;
const EVENT_CLICK$2 = `click${EVENT_KEY$e}`;
const EVENT_TRANSITIONEND = "transitionend";
const EVENT_MOUSEENTER$2 = "mouseenter";
const EVENT_MOUSELEAVE$2 = "mouseleave";
const EVENT_HIDE$9 = `hide${EVENT_KEY$e}`;
const EVENT_HIDDEN$9 = `hidden${EVENT_KEY$e}`;
const EVENT_SHOW$9 = `show${EVENT_KEY$e}`;
const EVENT_SHOWN$9 = `shown${EVENT_KEY$e}`;
const CLASS_NAME_ACTIVE$4 = "active";
const CLASS_NAME_SHOWN = "shown";
const CLASS_NAME_FIXED_ACTION_BTN = "fixed-action-btn";
const SELECTOR_ACTION_BUTTON = ".fixed-action-btn:not(.smooth-scroll) > .btn-floating";
const SELECTOR_LIST_ELEMENT = "ul .btn";
const SELECTOR_LIST$1 = "ul";
class Button2 extends Button$1 {
constructor(element2) {
super(element2);
this._fn = {};
if (this._element) {
Data$1.setData(this._element, DATA_KEY$g, this);
this._init();
Manipulator$1.setDataAttribute(this._element, `${this.constructor.NAME}-initialized`, true);
bindCallbackEventsIfNeeded(this.constructor);
}
}
// Static
static get NAME() {
return NAME$s;
}
static jQueryInterface(config, options) {
return this.each(function() {
let data = Data$1.getData(this, DATA_KEY$g);
const _config = typeof config === "object" && config;
if (!data && /dispose/.test(config)) {
return;
}
if (!data) {
data = new Button2(this, _config);
}
if (typeof config === "string") {
if (typeof data[config] === "undefined") {
throw new TypeError(`No method named "${config}"`);
}
data[config](options);
}
});
}
// Getters
get _actionButton() {
return SelectorEngine$1.findOne(SELECTOR_ACTION_BUTTON, this._element);
}
get _buttonListElements() {
return SelectorEngine$1.find(SELECTOR_LIST_ELEMENT, this._element);
}
get _buttonList() {
return SelectorEngine$1.findOne(SELECTOR_LIST$1, this._element);
}
get _isTouchDevice() {
return "ontouchstart" in document.documentElement;
}
// Public
show() {
if (Manipulator$1.hasClass(this._element, CLASS_NAME_FIXED_ACTION_BTN)) {
EventHandler$1.off(this._buttonList, EVENT_TRANSITIONEND);
EventHandler$1.trigger(this._element, EVENT_SHOW$9);
this._bindListOpenTransitionEnd();
Manipulator$1.addStyle(this._element, { height: `${this._fullContainerHeight}px` });
this._toggleVisibility(true);
}
}
hide() {
if (Manipulator$1.hasClass(this._element, CLASS_NAME_FIXED_ACTION_BTN)) {
EventHandler$1.off(this._buttonList, EVENT_TRANSITIONEND);
EventHandler$1.trigger(this._element, EVENT_HIDE$9);
this._bindListHideTransitionEnd();
this._toggleVisibility(false);
}
}
dispose() {
if (Manipulator$1.hasClass(this._element, CLASS_NAME_FIXED_ACTION_BTN)) {
EventHandler$1.off(this._actionButton, EVENT_CLICK$2);
this._actionButton.removeEventListener(EVENT_MOUSEENTER$2, this._fn.mouseenter);
this._element.removeEventListener(EVENT_MOUSELEAVE$2, this._fn.mouseleave);
}
Manipulator$1.removeDataAttribute(this._element, `${this.constructor.NAME}-initialized`);
super.dispose();
}
// Private
_init() {
if (Manipulator$1.hasClass(this._element, CLASS_NAME_FIXED_ACTION_BTN)) {
this._saveInitialHeights();
this._setInitialStyles();
this._bindInitialEvents();
}
}
_bindMouseEnter() {
this._actionButton.addEventListener(
EVENT_MOUSEENTER$2,
// prettier-ignore
this._fn.mouseenter = () => {
if (!this._isTouchDevice) {
this.show();
}
}
// prettier-ignore
);
}
_bindMouseLeave() {
this._element.addEventListener(
EVENT_MOUSELEAVE$2,
// prettier-ignore
this._fn.mouseleave = () => {
this.hide();
}
// prettier-ignore
);
}
_bindClick() {
EventHandler$1.on(this._actionButton, EVENT_CLICK$2, () => {
if (Manipulator$1.hasClass(this._element, CLASS_NAME_ACTIVE$4)) {
this.hide();
} else {
this.show();
}
});
}
_bindListHideTransitionEnd() {
EventHandler$1.on(this._buttonList, EVENT_TRANSITIONEND, (event) => {
if (event.propertyName === "transform") {
EventHandler$1.off(this._buttonList, EVENT_TRANSITIONEND);
this._element.style.height = `${this._initialContainerHeight}px`;
EventHandler$1.trigger(this._element, EVENT_HIDDEN$9);
}
});
}
_bindListOpenTransitionEnd() {
EventHandler$1.on(this._buttonList, EVENT_TRANSITIONEND, (event) => {
if (event.propertyName === "transform") {
EventHandler$1.off(this._buttonList, EVENT_TRANSITIONEND);
EventHandler$1.trigger(this._element, EVENT_SHOWN$9);
}
});
}
_toggleVisibility(isVisible2) {
const action = isVisible2 ? "addClass" : "removeClass";
const listTranslate = isVisible2 ? "translate(0)" : `translateY(${this._fullContainerHeight}px)`;
Manipulator$1.addStyle(this._buttonList, { transform: listTranslate });
if (this._buttonListElements) {
this._buttonListElements.forEach((el) => Manipulator$1[action](el, CLASS_NAME_SHOWN));
}
Manipulator$1[action](this._element, CLASS_NAME_ACTIVE$4);
}
_getHeight(element2) {
const computed = window.getComputedStyle(element2);
const height = parseFloat(computed.getPropertyValue("height"));
return height;
}
_saveInitialHeights() {
this._initialContainerHeight = this._getHeight(this._element);
this._initialListHeight = this._getHeight(this._buttonList);
this._fullContainerHeight = this._initialContainerHeight + this._initialListHeight;
}
_bindInitialEvents() {
this._bindClick();
this._bindMouseEnter();
this._bindMouseLeave();
}
_setInitialStyles() {
this._buttonList.style.marginBottom = `${this._initialContainerHeight}px`;
this._buttonList.style.transform = `translateY(${this._fullContainerHeight}px)`;
this._element.style.height = `${this._initialContainerHeight}px`;
}
}
const getSelector = (element2) => {
let selector = element2.getAttribute("data-mdb-target");
if (!selector || selector === "#") {
let hrefAttribute = element2.getAttribute("href");
if (!hrefAttribute || !hrefAttribute.includes("#") && !hrefAttribute.startsWith(".")) {
return null;
}
if (hrefAttribute.includes("#") && !hrefAttribute.startsWith("#")) {
hrefAttribute = `#${hrefAttribute.split("#")[1]}`;
}
selector = hrefAttribute && hrefAttribute !== "#" ? hrefAttribute.trim() : null;
}
return selector ? selector.split(",").map((sel) => parseSelector(sel)).join(",") : null;
};
const SelectorEngine = {
find(selector, element2 = document.documentElement) {
return [].concat(...Element.prototype.querySelectorAll.call(element2, selector));
},
findOne(selector, element2 = document.documentElement) {
return Element.prototype.querySelector.call(element2, selector);
},
children(element2, selector) {
return [].concat(...element2.children).filter((child) => child.matches(selector));
},
parents(element2, selector) {
const parents = [];
let ancestor = element2.parentNode.closest(selector);
while (ancestor) {
parents.push(ancestor);
ancestor = ancestor.parentNode.closest(selector);
}
return parents;
},
prev(element2, selector) {
let previous = element2.previousElementSibling;
while (previous) {
if (previous.matches(selector)) {
return [previous];
}
previous = previous.previousElementSibling;
}
return [];
},
// TODO: this is now unused; remove later along with prev()
next(element2, selector) {
let next = element2.nextElementSibling;
while (next) {
if (next.matches(selector)) {
return [next];
}
next = next.nextElementSibling;
}
return [];
},
focusableChildren(element2) {
const focusables = [
"a",
"button",
"input",
"textarea",
"select",
"details",
"[tabindex]",
'[contenteditable="true"]'
].map((selector) => `${selector}:not([tabindex^="-"])`).join(",");
return this.find(focusables, element2).filter((el) => !isDisabled(el) && isVisible(el));
},
getSelectorFromElement(element2) {
const selector = getSelector(element2);
if (selector) {
return SelectorEngine.findOne(selector) ? selector : null;
}
return null;
},
getElementFromSelector(element2) {
const selector = getSelector(element2);
return selector ? SelectorEngine.findOne(selector) : null;
},
getMultipleElementsFromSelector(element2) {
const selector = getSelector(element2);
return selector ? SelectorEngine.find(selector) : [];
}
};
const NAME$r = "backdrop";
const CLASS_NAME_FADE$6 = "fade";
const CLASS_NAME_SHOW$9 = "show";
const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$r}`;
const Default$e = {
className: "modal-backdrop",
clickCallback: null,
isAnimated: false,
isVisible: true,
// if false, we use the backdrop helper without adding any element to the dom
rootElement: "body"
// give the choice to place backdrop under different elements
};
const DefaultType$e = {
className: "string",
clickCallback: "(function|null)",
isAnimated: "boolean",
isVisible: "boolean",
rootElement: "(element|string)"
};
class Backdrop extends Config {
constructor(config) {
super();
this._config = this._getConfig(config);
this._isAppended = false;
this._element = null;
}
// Getters
static get Default() {
return Default$e;
}
static get DefaultType() {
return DefaultType$e;
}
static get NAME() {
return NAME$r;
}
// Public
show(callback) {
if (!this._config.isVisible) {
execute(callback);
return;
}
this._append();
const element2 = this._getElement();
if (this._config.isAnimated) {
reflow(element2);
}
element2.classList.add(CLASS_NAME_SHOW$9);
this._emulateAnimation(() => {
execute(callback);
});
}
hide(callback) {
if (!this._config.isVisible) {
execute(callback);
return;
}
this._getElement().classList.remove(CLASS_NAME_SHOW$9);
this._emulateAnimation(() => {
this.dispose();
execute(callback);
});
}
dispose() {
if (!this._isAppended) {
return;
}
EventHandler.off(this._element, EVENT_MOUSEDOWN);
this._element.remove();
this._isAppended = false;
}
// Private
_getElement() {
if (!this._element) {
const backdrop = document.createElement("div");
backdrop.className = this._config.className;
if (this._config.isAnimated) {
backdrop.classList.add(CLASS_NAME_FADE$6);
}
this._element = backdrop;
}
return this._element;
}
_configAfterMerge(config) {
config.rootElement = getElement(config.rootElement);
return config;
}
_append() {
if (this._isAppended) {
return;
}
const element2 = this._getElement();
this._config.rootElement.append(element2);
EventHandler.on(element2, EVENT_MOUSEDOWN, () => {
execute(this._config.clickCallback);
});
this._isAppended = true;
}
_emulateAnimation(callback) {
executeAfterTransition(callback, this._getElement(), this._config.isAnimated);
}
}
const enableDismissTrigger = (component, method = "hide") => {
const clickEvent = `click.dismiss${component.EVENT_KEY}`;
const name = component.NAME;
EventHandler.on(document, clickEvent, `[data-mdb-dismiss="${name}"]`, function(event) {
if (["A", "AREA"].includes(this.tagName)) {
event.preventDefault();
}
if (isDisabled(this)) {
return;
}
const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`);
const instance = component.getOrCreateInstance(target);
instance[method]();
});
};
const NAME$q = "focustrap";
const DATA_KEY$f = "bs.focustrap";
const EVENT_KEY$d = `.${DA