diff options
Diffstat (limited to 'vendor/twbs/bootstrap/dist/js/bootstrap.js')
| -rw-r--r-- | vendor/twbs/bootstrap/dist/js/bootstrap.js | 5795 |
1 files changed, 3179 insertions, 2616 deletions
diff --git a/vendor/twbs/bootstrap/dist/js/bootstrap.js b/vendor/twbs/bootstrap/dist/js/bootstrap.js index f46c53e6f..ec15092b7 100644 --- a/vendor/twbs/bootstrap/dist/js/bootstrap.js +++ b/vendor/twbs/bootstrap/dist/js/bootstrap.js @@ -1,349 +1,865 @@ /*! - * Bootstrap v4.6.0 (https://getbootstrap.com/) + * Bootstrap v5.0.1 (https://getbootstrap.com/) * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) */ (function (global, factory) { - typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery'), require('popper.js')) : - typeof define === 'function' && define.amd ? define(['exports', 'jquery', 'popper.js'], factory) : - (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.bootstrap = {}, global.jQuery, global.Popper)); -}(this, (function (exports, $, Popper) { 'use strict'; + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@popperjs/core')) : + typeof define === 'function' && define.amd ? define(['@popperjs/core'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.bootstrap = factory(global.Popper)); +}(this, (function (Popper) { 'use strict'; + + function _interopNamespace(e) { + if (e && e.__esModule) return e; + var n = Object.create(null); + if (e) { + Object.keys(e).forEach(function (k) { + if (k !== 'default') { + var d = Object.getOwnPropertyDescriptor(e, k); + Object.defineProperty(n, k, d.get ? d : { + enumerable: true, + get: function () { + return e[k]; + } + }); + } + }); + } + n['default'] = e; + return Object.freeze(n); + } - function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + var Popper__namespace = /*#__PURE__*/_interopNamespace(Popper); - var $__default = /*#__PURE__*/_interopDefaultLegacy($); - var Popper__default = /*#__PURE__*/_interopDefaultLegacy(Popper); + /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): dom/selector-engine.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ - function _defineProperties(target, props) { - for (var i = 0; i < props.length; i++) { - var descriptor = props[i]; - descriptor.enumerable = descriptor.enumerable || false; - descriptor.configurable = true; - if ("value" in descriptor) descriptor.writable = true; - Object.defineProperty(target, descriptor.key, descriptor); - } - } + /** + * ------------------------------------------------------------------------ + * Constants + * ------------------------------------------------------------------------ + */ + const NODE_TEXT = 3; + const SelectorEngine = { + find(selector, element = document.documentElement) { + return [].concat(...Element.prototype.querySelectorAll.call(element, selector)); + }, - function _createClass(Constructor, protoProps, staticProps) { - if (protoProps) _defineProperties(Constructor.prototype, protoProps); - if (staticProps) _defineProperties(Constructor, staticProps); - return Constructor; - } + findOne(selector, element = document.documentElement) { + return Element.prototype.querySelector.call(element, selector); + }, - function _extends() { - _extends = Object.assign || function (target) { - for (var i = 1; i < arguments.length; i++) { - var source = arguments[i]; + children(element, selector) { + return [].concat(...element.children).filter(child => child.matches(selector)); + }, - for (var key in source) { - if (Object.prototype.hasOwnProperty.call(source, key)) { - target[key] = source[key]; - } + parents(element, selector) { + const parents = []; + let ancestor = element.parentNode; + + while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) { + if (ancestor.matches(selector)) { + parents.push(ancestor); } + + ancestor = ancestor.parentNode; } - return target; - }; + return parents; + }, - return _extends.apply(this, arguments); - } + prev(element, selector) { + let previous = element.previousElementSibling; - function _inheritsLoose(subClass, superClass) { - subClass.prototype = Object.create(superClass.prototype); - subClass.prototype.constructor = subClass; - subClass.__proto__ = superClass; - } + while (previous) { + if (previous.matches(selector)) { + return [previous]; + } + + previous = previous.previousElementSibling; + } + + return []; + }, + + next(element, selector) { + let next = element.nextElementSibling; + + while (next) { + if (next.matches(selector)) { + return [next]; + } + + next = next.nextElementSibling; + } + + return []; + } + + }; /** * -------------------------------------------------------------------------- - * Bootstrap (v4.6.0): util.js + * Bootstrap (v5.0.1): util/index.js * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) * -------------------------------------------------------------------------- */ - /** - * ------------------------------------------------------------------------ - * Private TransitionEnd Helpers - * ------------------------------------------------------------------------ - */ - var TRANSITION_END = 'transitionend'; - var MAX_UID = 1000000; - var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp) + const MAX_UID = 1000000; + const MILLISECONDS_MULTIPLIER = 1000; + const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp) - function toType(obj) { - if (obj === null || typeof obj === 'undefined') { - return "" + obj; + const toType = obj => { + if (obj === null || obj === undefined) { + return `${obj}`; } return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); - } + }; + /** + * -------------------------------------------------------------------------- + * Public Util Api + * -------------------------------------------------------------------------- + */ - function getSpecialTransitionEndEvent() { - return { - bindType: TRANSITION_END, - delegateType: TRANSITION_END, - handle: function handle(event) { - if ($__default['default'](event.target).is(this)) { - return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params - } - return undefined; + const getUID = prefix => { + do { + prefix += Math.floor(Math.random() * MAX_UID); + } while (document.getElementById(prefix)); + + return prefix; + }; + + const getSelector = element => { + let selector = element.getAttribute('data-bs-target'); + + if (!selector || selector === '#') { + let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes, + // so everything starting with `#` or `.`. If a "real" URL is used as the selector, + // `document.querySelector` will rightfully complain it is invalid. + // See https://github.com/twbs/bootstrap/issues/32273 + + if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) { + return null; + } // Just in case some CMS puts out a full URL with the anchor appended + + + if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) { + hrefAttr = `#${hrefAttr.split('#')[1]}`; } - }; - } - function transitionEndEmulator(duration) { - var _this = this; + selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null; + } + + return selector; + }; + + const getSelectorFromElement = element => { + const selector = getSelector(element); + + if (selector) { + return document.querySelector(selector) ? selector : null; + } + + return null; + }; + + const getElementFromSelector = element => { + const selector = getSelector(element); + return selector ? document.querySelector(selector) : null; + }; + + const getTransitionDurationFromElement = element => { + if (!element) { + return 0; + } // Get transition-duration of the element - var called = false; - $__default['default'](this).one(Util.TRANSITION_END, function () { + + let { + transitionDuration, + transitionDelay + } = window.getComputedStyle(element); + const floatTransitionDuration = Number.parseFloat(transitionDuration); + const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found + + if (!floatTransitionDuration && !floatTransitionDelay) { + return 0; + } // If multiple durations are defined, take the first + + + transitionDuration = transitionDuration.split(',')[0]; + transitionDelay = transitionDelay.split(',')[0]; + return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; + }; + + const triggerTransitionEnd = element => { + element.dispatchEvent(new Event(TRANSITION_END)); + }; + + const isElement = obj => { + if (!obj || typeof obj !== 'object') { + return false; + } + + if (typeof obj.jquery !== 'undefined') { + obj = obj[0]; + } + + return typeof obj.nodeType !== 'undefined'; + }; + + const getElement = obj => { + if (isElement(obj)) { + // it's a jQuery object or a node element + return obj.jquery ? obj[0] : obj; + } + + if (typeof obj === 'string' && obj.length > 0) { + return SelectorEngine.findOne(obj); + } + + return null; + }; + + const emulateTransitionEnd = (element, duration) => { + let called = false; + const durationPadding = 5; + const emulatedDuration = duration + durationPadding; + + function listener() { called = true; - }); - setTimeout(function () { + element.removeEventListener(TRANSITION_END, listener); + } + + element.addEventListener(TRANSITION_END, listener); + setTimeout(() => { if (!called) { - Util.triggerTransitionEnd(_this); + triggerTransitionEnd(element); } - }, duration); - return this; - } + }, emulatedDuration); + }; + + const typeCheckConfig = (componentName, config, configTypes) => { + Object.keys(configTypes).forEach(property => { + const expectedTypes = configTypes[property]; + const value = config[property]; + const valueType = value && isElement(value) ? 'element' : toType(value); + + if (!new RegExp(expectedTypes).test(valueType)) { + throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); + } + }); + }; + + const isVisible = element => { + if (!element) { + return false; + } + + if (element.style && element.parentNode && element.parentNode.style) { + const elementStyle = getComputedStyle(element); + const parentNodeStyle = getComputedStyle(element.parentNode); + return elementStyle.display !== 'none' && parentNodeStyle.display !== 'none' && elementStyle.visibility !== 'hidden'; + } + + return false; + }; + + const isDisabled = element => { + if (!element || element.nodeType !== Node.ELEMENT_NODE) { + return true; + } + + if (element.classList.contains('disabled')) { + return true; + } + + if (typeof element.disabled !== 'undefined') { + return element.disabled; + } + + return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'; + }; + + const findShadowRoot = element => { + if (!document.documentElement.attachShadow) { + return null; + } // Can find the shadow root otherwise it'll return the document + + + if (typeof element.getRootNode === 'function') { + const root = element.getRootNode(); + return root instanceof ShadowRoot ? root : null; + } + + if (element instanceof ShadowRoot) { + return element; + } // when we don't find a shadow root + + + if (!element.parentNode) { + return null; + } + + return findShadowRoot(element.parentNode); + }; + + const noop = () => {}; + + const reflow = element => element.offsetHeight; + + const getjQuery = () => { + const { + jQuery + } = window; + + if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { + return jQuery; + } + + return null; + }; + + const onDOMContentLoaded = callback => { + if (document.readyState === 'loading') { + document.addEventListener('DOMContentLoaded', callback); + } else { + callback(); + } + }; + + const isRTL = () => document.documentElement.dir === 'rtl'; + + const defineJQueryPlugin = plugin => { + onDOMContentLoaded(() => { + const $ = getjQuery(); + /* istanbul ignore if */ + + if ($) { + const name = plugin.NAME; + const JQUERY_NO_CONFLICT = $.fn[name]; + $.fn[name] = plugin.jQueryInterface; + $.fn[name].Constructor = plugin; + + $.fn[name].noConflict = () => { + $.fn[name] = JQUERY_NO_CONFLICT; + return plugin.jQueryInterface; + }; + } + }); + }; + + const execute = callback => { + if (typeof callback === 'function') { + callback(); + } + }; - function setTransitionEndSupport() { - $__default['default'].fn.emulateTransitionEnd = transitionEndEmulator; - $__default['default'].event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent(); - } /** * -------------------------------------------------------------------------- - * Public Util Api + * Bootstrap (v5.0.1): dom/data.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) * -------------------------------------------------------------------------- */ + /** + * ------------------------------------------------------------------------ + * Constants + * ------------------------------------------------------------------------ + */ + const elementMap = new Map(); + var Data = { + set(element, key, instance) { + if (!elementMap.has(element)) { + elementMap.set(element, new Map()); + } + + const instanceMap = elementMap.get(element); // make it clear we only want one instance per element + // can be removed later when multiple key/instances are fine to be used - var Util = { - TRANSITION_END: 'bsTransitionEnd', - getUID: function getUID(prefix) { - do { - prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here - } while (document.getElementById(prefix)); + if (!instanceMap.has(key) && instanceMap.size !== 0) { + // eslint-disable-next-line no-console + console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`); + return; + } - return prefix; + instanceMap.set(key, instance); }, - getSelectorFromElement: function getSelectorFromElement(element) { - var selector = element.getAttribute('data-target'); - if (!selector || selector === '#') { - var hrefAttr = element.getAttribute('href'); - selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : ''; + get(element, key) { + if (elementMap.has(element)) { + return elementMap.get(element).get(key) || null; } - try { - return document.querySelector(selector) ? selector : null; - } catch (_) { - return null; - } + return null; }, - getTransitionDurationFromElement: function getTransitionDurationFromElement(element) { - if (!element) { - return 0; - } // Get transition-duration of the element + remove(element, key) { + if (!elementMap.has(element)) { + return; + } - var transitionDuration = $__default['default'](element).css('transition-duration'); - var transitionDelay = $__default['default'](element).css('transition-delay'); - var floatTransitionDuration = parseFloat(transitionDuration); - var floatTransitionDelay = parseFloat(transitionDelay); // Return 0 if element or transition duration is not found + const instanceMap = elementMap.get(element); + instanceMap.delete(key); // free up element references if there are no instances left for an element - if (!floatTransitionDuration && !floatTransitionDelay) { - return 0; - } // If multiple durations are defined, take the first + if (instanceMap.size === 0) { + elementMap.delete(element); + } + } + }; - transitionDuration = transitionDuration.split(',')[0]; - transitionDelay = transitionDelay.split(',')[0]; - return (parseFloat(transitionDuration) + parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; - }, - reflow: function reflow(element) { - return element.offsetHeight; - }, - triggerTransitionEnd: function triggerTransitionEnd(element) { - $__default['default'](element).trigger(TRANSITION_END); - }, - supportsTransitionEnd: function supportsTransitionEnd() { - return Boolean(TRANSITION_END); + /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): dom/event-handler.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** + * ------------------------------------------------------------------------ + * Constants + * ------------------------------------------------------------------------ + */ + + const namespaceRegex = /[^.]*(?=\..*)\.|.*/; + const stripNameRegex = /\..*/; + const stripUidRegex = /::\d+$/; + const eventRegistry = {}; // Events storage + + let uidEvent = 1; + const customEvents = { + mouseenter: 'mouseover', + mouseleave: 'mouseout' + }; + const customEventsRegex = /^(mouseenter|mouseleave)/i; + const nativeEvents = 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']); + /** + * ------------------------------------------------------------------------ + * Private methods + * ------------------------------------------------------------------------ + */ + + function getUidEvent(element, uid) { + return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++; + } + + function getEvent(element) { + const uid = getUidEvent(element); + element.uidEvent = uid; + eventRegistry[uid] = eventRegistry[uid] || {}; + return eventRegistry[uid]; + } + + function bootstrapHandler(element, fn) { + return function handler(event) { + event.delegateTarget = element; + + if (handler.oneOff) { + EventHandler.off(element, event.type, fn); + } + + return fn.apply(element, [event]); + }; + } + + function bootstrapDelegationHandler(element, selector, fn) { + return function handler(event) { + const domElements = element.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) { + // eslint-disable-next-line unicorn/consistent-destructuring + EventHandler.off(element, event.type, selector, fn); + } + + return fn.apply(target, [event]); + } + } + } // To please ESLint + + + return null; + }; + } + + function findHandler(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 = getTypeEvent(originalTypeEvent); + const isNative = nativeEvents.has(typeEvent); + + if (!isNative) { + typeEvent = originalTypeEvent; + } + + return [delegation, originalHandler, typeEvent]; + } + + function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) { + if (typeof originalTypeEvent !== 'string' || !element) { + return; + } + + if (!handler) { + handler = delegationFn; + delegationFn = null; + } // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position + // this prevents the handler from being dispatched the same way as mouseover or mouseout does + + + if (customEventsRegex.test(originalTypeEvent)) { + const wrapFn = fn => { + return function (event) { + if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) { + return fn.call(this, event); + } + }; + }; + + if (delegationFn) { + delegationFn = wrapFn(delegationFn); + } else { + handler = wrapFn(handler); + } + } + + const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn); + const events = getEvent(element); + const handlers = events[typeEvent] || (events[typeEvent] = {}); + const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null); + + if (previousFn) { + previousFn.oneOff = previousFn.oneOff && oneOff; + return; + } + + const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, '')); + const fn = delegation ? bootstrapDelegationHandler(element, handler, delegationFn) : bootstrapHandler(element, handler); + fn.delegationSelector = delegation ? handler : null; + fn.originalHandler = originalHandler; + fn.oneOff = oneOff; + fn.uidEvent = uid; + handlers[uid] = fn; + element.addEventListener(typeEvent, fn, delegation); + } + + function removeHandler(element, events, typeEvent, handler, delegationSelector) { + const fn = findHandler(events[typeEvent], handler, delegationSelector); + + if (!fn) { + return; + } + + element.removeEventListener(typeEvent, fn, Boolean(delegationSelector)); + delete events[typeEvent][fn.uidEvent]; + } + + function removeNamespacedHandlers(element, events, typeEvent, namespace) { + const storeElementEvent = events[typeEvent] || {}; + Object.keys(storeElementEvent).forEach(handlerKey => { + if (handlerKey.includes(namespace)) { + const event = storeElementEvent[handlerKey]; + removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector); + } + }); + } + + function getTypeEvent(event) { + // allow to get the native events from namespaced events ('click.bs.button' --> 'click') + event = event.replace(stripNameRegex, ''); + return customEvents[event] || event; + } + + const EventHandler = { + on(element, event, handler, delegationFn) { + addHandler(element, event, handler, delegationFn, false); }, - isElement: function isElement(obj) { - return (obj[0] || obj).nodeType; + + one(element, event, handler, delegationFn) { + addHandler(element, event, handler, delegationFn, true); }, - typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) { - for (var property in configTypes) { - if (Object.prototype.hasOwnProperty.call(configTypes, property)) { - var expectedTypes = configTypes[property]; - var value = config[property]; - var valueType = value && Util.isElement(value) ? 'element' : toType(value); - - if (!new RegExp(expectedTypes).test(valueType)) { - throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\".")); - } + + off(element, originalTypeEvent, handler, delegationFn) { + if (typeof originalTypeEvent !== 'string' || !element) { + return; + } + + const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn); + const inNamespace = typeEvent !== originalTypeEvent; + const events = getEvent(element); + const isNamespace = originalTypeEvent.startsWith('.'); + + if (typeof originalHandler !== 'undefined') { + // Simplest case: handler is passed, remove that listener ONLY. + if (!events || !events[typeEvent]) { + return; } + + removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null); + return; } + + if (isNamespace) { + Object.keys(events).forEach(elementEvent => { + removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1)); + }); + } + + const storeElementEvent = events[typeEvent] || {}; + Object.keys(storeElementEvent).forEach(keyHandlers => { + const handlerKey = keyHandlers.replace(stripUidRegex, ''); + + if (!inNamespace || originalTypeEvent.includes(handlerKey)) { + const event = storeElementEvent[keyHandlers]; + removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector); + } + }); }, - findShadowRoot: function findShadowRoot(element) { - if (!document.documentElement.attachShadow) { + + trigger(element, event, args) { + if (typeof event !== 'string' || !element) { return null; - } // Can find the shadow root otherwise it'll return the document + } + const $ = getjQuery(); + const typeEvent = getTypeEvent(event); + const inNamespace = event !== typeEvent; + const isNative = nativeEvents.has(typeEvent); + let jQueryEvent; + let bubbles = true; + let nativeDispatch = true; + let defaultPrevented = false; + let evt = null; - if (typeof element.getRootNode === 'function') { - var root = element.getRootNode(); - return root instanceof ShadowRoot ? root : null; + if (inNamespace && $) { + jQueryEvent = $.Event(event, args); + $(element).trigger(jQueryEvent); + bubbles = !jQueryEvent.isPropagationStopped(); + nativeDispatch = !jQueryEvent.isImmediatePropagationStopped(); + defaultPrevented = jQueryEvent.isDefaultPrevented(); } - if (element instanceof ShadowRoot) { - return element; - } // when we don't find a shadow root + if (isNative) { + evt = document.createEvent('HTMLEvents'); + evt.initEvent(typeEvent, bubbles, true); + } else { + evt = new CustomEvent(event, { + bubbles, + cancelable: true + }); + } // merge custom information in our event - if (!element.parentNode) { - return null; + if (typeof args !== 'undefined') { + Object.keys(args).forEach(key => { + Object.defineProperty(evt, key, { + get() { + return args[key]; + } + + }); + }); } - return Util.findShadowRoot(element.parentNode); - }, - jQueryDetection: function jQueryDetection() { - if (typeof $__default['default'] === 'undefined') { - throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.'); + if (defaultPrevented) { + evt.preventDefault(); } - var version = $__default['default'].fn.jquery.split(' ')[0].split('.'); - var minMajor = 1; - var ltMajor = 2; - var minMinor = 9; - var minPatch = 1; - var maxMajor = 4; + if (nativeDispatch) { + element.dispatchEvent(evt); + } - if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) { - throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0'); + if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') { + jQueryEvent.preventDefault(); } + + return evt; } + }; - Util.jQueryDetection(); - setTransitionEndSupport(); /** - * ------------------------------------------------------------------------ - * Constants - * ------------------------------------------------------------------------ + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): base-component.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- */ - - var NAME = 'alert'; - var VERSION = '4.6.0'; - var DATA_KEY = 'bs.alert'; - var EVENT_KEY = "." + DATA_KEY; - var DATA_API_KEY = '.data-api'; - var JQUERY_NO_CONFLICT = $__default['default'].fn[NAME]; - var SELECTOR_DISMISS = '[data-dismiss="alert"]'; - var EVENT_CLOSE = "close" + EVENT_KEY; - var EVENT_CLOSED = "closed" + EVENT_KEY; - var EVENT_CLICK_DATA_API = "click" + EVENT_KEY + DATA_API_KEY; - var CLASS_NAME_ALERT = 'alert'; - var CLASS_NAME_FADE = 'fade'; - var CLASS_NAME_SHOW = 'show'; /** * ------------------------------------------------------------------------ - * Class Definition + * Constants * ------------------------------------------------------------------------ */ - var Alert = /*#__PURE__*/function () { - function Alert(element) { - this._element = element; - } // Getters - + const VERSION = '5.0.1'; - var _proto = Alert.prototype; + class BaseComponent { + constructor(element) { + element = getElement(element); - // Public - _proto.close = function close(element) { - var rootElement = this._element; - - if (element) { - rootElement = this._getRootElement(element); + if (!element) { + return; } - var customEvent = this._triggerCloseEvent(rootElement); + this._element = element; + Data.set(this._element, this.constructor.DATA_KEY, this); + } - if (customEvent.isDefaultPrevented()) { + dispose() { + Data.remove(this._element, this.constructor.DATA_KEY); + EventHandler.off(this._element, this.constructor.EVENT_KEY); + Object.getOwnPropertyNames(this).forEach(propertyName => { + this[propertyName] = null; + }); + } + + _queueCallback(callback, element, isAnimated = true) { + if (!isAnimated) { + execute(callback); return; } - this._removeElement(rootElement); - }; + const transitionDuration = getTransitionDurationFromElement(element); + EventHandler.one(element, 'transitionend', () => execute(callback)); + emulateTransitionEnd(element, transitionDuration); + } + /** Static */ - _proto.dispose = function dispose() { - $__default['default'].removeData(this._element, DATA_KEY); - this._element = null; - } // Private - ; - _proto._getRootElement = function _getRootElement(element) { - var selector = Util.getSelectorFromElement(element); - var parent = false; + static getInstance(element) { + return Data.get(element, this.DATA_KEY); + } - if (selector) { - parent = document.querySelector(selector); - } + static get VERSION() { + return VERSION; + } - if (!parent) { - parent = $__default['default'](element).closest("." + CLASS_NAME_ALERT)[0]; - } + static get NAME() { + throw new Error('You have to implement the static method "NAME", for each component!'); + } - return parent; - }; + static get DATA_KEY() { + return `bs.${this.NAME}`; + } - _proto._triggerCloseEvent = function _triggerCloseEvent(element) { - var closeEvent = $__default['default'].Event(EVENT_CLOSE); - $__default['default'](element).trigger(closeEvent); - return closeEvent; - }; + static get EVENT_KEY() { + return `.${this.DATA_KEY}`; + } - _proto._removeElement = function _removeElement(element) { - var _this = this; + } + + /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): alert.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** + * ------------------------------------------------------------------------ + * Constants + * ------------------------------------------------------------------------ + */ + + const NAME$c = 'alert'; + const DATA_KEY$b = 'bs.alert'; + const EVENT_KEY$b = `.${DATA_KEY$b}`; + const DATA_API_KEY$8 = '.data-api'; + const SELECTOR_DISMISS = '[data-bs-dismiss="alert"]'; + const EVENT_CLOSE = `close${EVENT_KEY$b}`; + const EVENT_CLOSED = `closed${EVENT_KEY$b}`; + const EVENT_CLICK_DATA_API$7 = `click${EVENT_KEY$b}${DATA_API_KEY$8}`; + const CLASS_NAME_ALERT = 'alert'; + const CLASS_NAME_FADE$6 = 'fade'; + const CLASS_NAME_SHOW$9 = 'show'; + /** + * ------------------------------------------------------------------------ + * Class Definition + * ------------------------------------------------------------------------ + */ + + class Alert extends BaseComponent { + // Getters + static get NAME() { + return NAME$c; + } // Public - $__default['default'](element).removeClass(CLASS_NAME_SHOW); - if (!$__default['default'](element).hasClass(CLASS_NAME_FADE)) { - this._destroyElement(element); + close(element) { + const rootElement = element ? this._getRootElement(element) : this._element; + const customEvent = this._triggerCloseEvent(rootElement); + + if (customEvent === null || customEvent.defaultPrevented) { return; } - var transitionDuration = Util.getTransitionDurationFromElement(element); - $__default['default'](element).one(Util.TRANSITION_END, function (event) { - return _this._destroyElement(element, event); - }).emulateTransitionEnd(transitionDuration); - }; + this._removeElement(rootElement); + } // Private + + + _getRootElement(element) { + return getElementFromSelector(element) || element.closest(`.${CLASS_NAME_ALERT}`); + } + + _triggerCloseEvent(element) { + return EventHandler.trigger(element, EVENT_CLOSE); + } + + _removeElement(element) { + element.classList.remove(CLASS_NAME_SHOW$9); + const isAnimated = element.classList.contains(CLASS_NAME_FADE$6); + + this._queueCallback(() => this._destroyElement(element), element, isAnimated); + } - _proto._destroyElement = function _destroyElement(element) { - $__default['default'](element).detach().trigger(EVENT_CLOSED).remove(); + _destroyElement(element) { + if (element.parentNode) { + element.parentNode.removeChild(element); + } + + EventHandler.trigger(element, EVENT_CLOSED); } // Static - ; - Alert._jQueryInterface = function _jQueryInterface(config) { + + static jQueryInterface(config) { return this.each(function () { - var $element = $__default['default'](this); - var data = $element.data(DATA_KEY); + let data = Data.get(this, DATA_KEY$b); if (!data) { data = new Alert(this); - $element.data(DATA_KEY, data); } if (config === 'close') { data[config](this); } }); - }; + } - Alert._handleDismiss = function _handleDismiss(alertInstance) { + static handleDismiss(alertInstance) { return function (event) { if (event) { event.preventDefault(); @@ -351,17 +867,9 @@ alertInstance.close(this); }; - }; - - _createClass(Alert, null, [{ - key: "VERSION", - get: function get() { - return VERSION; - } - }]); + } - return Alert; - }(); + } /** * ------------------------------------------------------------------------ * Data Api implementation @@ -369,143 +877,69 @@ */ - $__default['default'](document).on(EVENT_CLICK_DATA_API, SELECTOR_DISMISS, Alert._handleDismiss(new Alert())); + EventHandler.on(document, EVENT_CLICK_DATA_API$7, SELECTOR_DISMISS, Alert.handleDismiss(new Alert())); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ + * add .Alert to jQuery only if jQuery is present */ - $__default['default'].fn[NAME] = Alert._jQueryInterface; - $__default['default'].fn[NAME].Constructor = Alert; - - $__default['default'].fn[NAME].noConflict = function () { - $__default['default'].fn[NAME] = JQUERY_NO_CONFLICT; - return Alert._jQueryInterface; - }; + defineJQueryPlugin(Alert); /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): button.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ - var NAME$1 = 'button'; - var VERSION$1 = '4.6.0'; - var DATA_KEY$1 = 'bs.button'; - var EVENT_KEY$1 = "." + DATA_KEY$1; - var DATA_API_KEY$1 = '.data-api'; - var JQUERY_NO_CONFLICT$1 = $__default['default'].fn[NAME$1]; - var CLASS_NAME_ACTIVE = 'active'; - var CLASS_NAME_BUTTON = 'btn'; - var CLASS_NAME_FOCUS = 'focus'; - var SELECTOR_DATA_TOGGLE_CARROT = '[data-toggle^="button"]'; - var SELECTOR_DATA_TOGGLES = '[data-toggle="buttons"]'; - var SELECTOR_DATA_TOGGLE = '[data-toggle="button"]'; - var SELECTOR_DATA_TOGGLES_BUTTONS = '[data-toggle="buttons"] .btn'; - var SELECTOR_INPUT = 'input:not([type="hidden"])'; - var SELECTOR_ACTIVE = '.active'; - var SELECTOR_BUTTON = '.btn'; - var EVENT_CLICK_DATA_API$1 = "click" + EVENT_KEY$1 + DATA_API_KEY$1; - var EVENT_FOCUS_BLUR_DATA_API = "focus" + EVENT_KEY$1 + DATA_API_KEY$1 + " " + ("blur" + EVENT_KEY$1 + DATA_API_KEY$1); - var EVENT_LOAD_DATA_API = "load" + EVENT_KEY$1 + DATA_API_KEY$1; + const NAME$b = 'button'; + const DATA_KEY$a = 'bs.button'; + const EVENT_KEY$a = `.${DATA_KEY$a}`; + const DATA_API_KEY$7 = '.data-api'; + const CLASS_NAME_ACTIVE$3 = 'active'; + const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]'; + const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$7}`; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ - var Button = /*#__PURE__*/function () { - function Button(element) { - this._element = element; - this.shouldAvoidTriggerChange = false; - } // Getters - + class Button extends BaseComponent { + // Getters + static get NAME() { + return NAME$b; + } // Public - var _proto = Button.prototype; - - // Public - _proto.toggle = function toggle() { - var triggerChangeEvent = true; - var addAriaPressed = true; - var rootElement = $__default['default'](this._element).closest(SELECTOR_DATA_TOGGLES)[0]; - - if (rootElement) { - var input = this._element.querySelector(SELECTOR_INPUT); - - if (input) { - if (input.type === 'radio') { - if (input.checked && this._element.classList.contains(CLASS_NAME_ACTIVE)) { - triggerChangeEvent = false; - } else { - var activeElement = rootElement.querySelector(SELECTOR_ACTIVE); - - if (activeElement) { - $__default['default'](activeElement).removeClass(CLASS_NAME_ACTIVE); - } - } - } - if (triggerChangeEvent) { - // if it's not a radio button or checkbox don't add a pointless/invalid checked property to the input - if (input.type === 'checkbox' || input.type === 'radio') { - input.checked = !this._element.classList.contains(CLASS_NAME_ACTIVE); - } - - if (!this.shouldAvoidTriggerChange) { - $__default['default'](input).trigger('change'); - } - } - - input.focus(); - addAriaPressed = false; - } - } - - if (!(this._element.hasAttribute('disabled') || this._element.classList.contains('disabled'))) { - if (addAriaPressed) { - this._element.setAttribute('aria-pressed', !this._element.classList.contains(CLASS_NAME_ACTIVE)); - } - - if (triggerChangeEvent) { - $__default['default'](this._element).toggleClass(CLASS_NAME_ACTIVE); - } - } - }; - - _proto.dispose = function dispose() { - $__default['default'].removeData(this._element, DATA_KEY$1); - this._element = null; + toggle() { + // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method + this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3)); } // Static - ; - Button._jQueryInterface = function _jQueryInterface(config, avoidTriggerChange) { + + static jQueryInterface(config) { return this.each(function () { - var $element = $__default['default'](this); - var data = $element.data(DATA_KEY$1); + let data = Data.get(this, DATA_KEY$a); if (!data) { data = new Button(this); - $element.data(DATA_KEY$1, data); } - data.shouldAvoidTriggerChange = avoidTriggerChange; - if (config === 'toggle') { data[config](); } }); - }; - - _createClass(Button, null, [{ - key: "VERSION", - get: function get() { - return VERSION$1; - } - }]); + } - return Button; - }(); + } /** * ------------------------------------------------------------------------ * Data Api implementation @@ -513,96 +947,122 @@ */ - $__default['default'](document).on(EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE_CARROT, function (event) { - var button = event.target; - var initialButton = button; + EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => { + event.preventDefault(); + const button = event.target.closest(SELECTOR_DATA_TOGGLE$5); + let data = Data.get(button, DATA_KEY$a); - if (!$__default['default'](button).hasClass(CLASS_NAME_BUTTON)) { - button = $__default['default'](button).closest(SELECTOR_BUTTON)[0]; + if (!data) { + data = new Button(button); } - if (!button || button.hasAttribute('disabled') || button.classList.contains('disabled')) { - event.preventDefault(); // work around Firefox bug #1540995 - } else { - var inputBtn = button.querySelector(SELECTOR_INPUT); + data.toggle(); + }); + /** + * ------------------------------------------------------------------------ + * jQuery + * ------------------------------------------------------------------------ + * add .Button to jQuery only if jQuery is present + */ - if (inputBtn && (inputBtn.hasAttribute('disabled') || inputBtn.classList.contains('disabled'))) { - event.preventDefault(); // work around Firefox bug #1540995 + defineJQueryPlugin(Button); - return; - } + /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): dom/manipulator.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + function normalizeData(val) { + if (val === 'true') { + return true; + } - if (initialButton.tagName === 'INPUT' || button.tagName !== 'LABEL') { - Button._jQueryInterface.call($__default['default'](button), 'toggle', initialButton.tagName === 'INPUT'); - } + if (val === 'false') { + return false; } - }).on(EVENT_FOCUS_BLUR_DATA_API, SELECTOR_DATA_TOGGLE_CARROT, function (event) { - var button = $__default['default'](event.target).closest(SELECTOR_BUTTON)[0]; - $__default['default'](button).toggleClass(CLASS_NAME_FOCUS, /^focus(in)?$/.test(event.type)); - }); - $__default['default'](window).on(EVENT_LOAD_DATA_API, function () { - // ensure correct active class is set to match the controls' actual values/states - // find all checkboxes/readio buttons inside data-toggle groups - var buttons = [].slice.call(document.querySelectorAll(SELECTOR_DATA_TOGGLES_BUTTONS)); - for (var i = 0, len = buttons.length; i < len; i++) { - var button = buttons[i]; - var input = button.querySelector(SELECTOR_INPUT); + if (val === Number(val).toString()) { + return Number(val); + } - if (input.checked || input.hasAttribute('checked')) { - button.classList.add(CLASS_NAME_ACTIVE); - } else { - button.classList.remove(CLASS_NAME_ACTIVE); - } - } // find all button toggles + if (val === '' || val === 'null') { + return null; + } + return val; + } - buttons = [].slice.call(document.querySelectorAll(SELECTOR_DATA_TOGGLE)); + function normalizeDataKey(key) { + return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`); + } - for (var _i = 0, _len = buttons.length; _i < _len; _i++) { - var _button = buttons[_i]; + const Manipulator = { + setDataAttribute(element, key, value) { + element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value); + }, - if (_button.getAttribute('aria-pressed') === 'true') { - _button.classList.add(CLASS_NAME_ACTIVE); - } else { - _button.classList.remove(CLASS_NAME_ACTIVE); + removeDataAttribute(element, key) { + element.removeAttribute(`data-bs-${normalizeDataKey(key)}`); + }, + + getDataAttributes(element) { + if (!element) { + return {}; } - } - }); - /** - * ------------------------------------------------------------------------ - * jQuery - * ------------------------------------------------------------------------ - */ - $__default['default'].fn[NAME$1] = Button._jQueryInterface; - $__default['default'].fn[NAME$1].Constructor = Button; + const attributes = {}; + Object.keys(element.dataset).filter(key => key.startsWith('bs')).forEach(key => { + let pureKey = key.replace(/^bs/, ''); + pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length); + attributes[pureKey] = normalizeData(element.dataset[key]); + }); + return attributes; + }, + + getDataAttribute(element, key) { + return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`)); + }, + + offset(element) { + const rect = element.getBoundingClientRect(); + return { + top: rect.top + document.body.scrollTop, + left: rect.left + document.body.scrollLeft + }; + }, + + position(element) { + return { + top: element.offsetTop, + left: element.offsetLeft + }; + } - $__default['default'].fn[NAME$1].noConflict = function () { - $__default['default'].fn[NAME$1] = JQUERY_NO_CONFLICT$1; - return Button._jQueryInterface; }; /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): carousel.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ - var NAME$2 = 'carousel'; - var VERSION$2 = '4.6.0'; - var DATA_KEY$2 = 'bs.carousel'; - var EVENT_KEY$2 = "." + DATA_KEY$2; - var DATA_API_KEY$2 = '.data-api'; - var JQUERY_NO_CONFLICT$2 = $__default['default'].fn[NAME$2]; - var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key - - var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key + const NAME$a = 'carousel'; + const DATA_KEY$9 = 'bs.carousel'; + const EVENT_KEY$9 = `.${DATA_KEY$9}`; + const DATA_API_KEY$6 = '.data-api'; + const ARROW_LEFT_KEY = 'ArrowLeft'; + const ARROW_RIGHT_KEY = 'ArrowRight'; + const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch - var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch - - var SWIPE_THRESHOLD = 40; - var Default = { + const SWIPE_THRESHOLD = 40; + const Default$9 = { interval: 5000, keyboard: true, slide: false, @@ -610,7 +1070,7 @@ wrap: true, touch: true }; - var DefaultType = { + const DefaultType$9 = { interval: '(number|boolean)', keyboard: 'boolean', slide: '(boolean|string)', @@ -618,51 +1078,51 @@ wrap: 'boolean', touch: 'boolean' }; - var DIRECTION_NEXT = 'next'; - var DIRECTION_PREV = 'prev'; - var DIRECTION_LEFT = 'left'; - var DIRECTION_RIGHT = 'right'; - var EVENT_SLIDE = "slide" + EVENT_KEY$2; - var EVENT_SLID = "slid" + EVENT_KEY$2; - var EVENT_KEYDOWN = "keydown" + EVENT_KEY$2; - var EVENT_MOUSEENTER = "mouseenter" + EVENT_KEY$2; - var EVENT_MOUSELEAVE = "mouseleave" + EVENT_KEY$2; - var EVENT_TOUCHSTART = "touchstart" + EVENT_KEY$2; - var EVENT_TOUCHMOVE = "touchmove" + EVENT_KEY$2; - var EVENT_TOUCHEND = "touchend" + EVENT_KEY$2; - var EVENT_POINTERDOWN = "pointerdown" + EVENT_KEY$2; - var EVENT_POINTERUP = "pointerup" + EVENT_KEY$2; - var EVENT_DRAG_START = "dragstart" + EVENT_KEY$2; - var EVENT_LOAD_DATA_API$1 = "load" + EVENT_KEY$2 + DATA_API_KEY$2; - var EVENT_CLICK_DATA_API$2 = "click" + EVENT_KEY$2 + DATA_API_KEY$2; - var CLASS_NAME_CAROUSEL = 'carousel'; - var CLASS_NAME_ACTIVE$1 = 'active'; - var CLASS_NAME_SLIDE = 'slide'; - var CLASS_NAME_RIGHT = 'carousel-item-right'; - var CLASS_NAME_LEFT = 'carousel-item-left'; - var CLASS_NAME_NEXT = 'carousel-item-next'; - var CLASS_NAME_PREV = 'carousel-item-prev'; - var CLASS_NAME_POINTER_EVENT = 'pointer-event'; - var SELECTOR_ACTIVE$1 = '.active'; - var SELECTOR_ACTIVE_ITEM = '.active.carousel-item'; - var SELECTOR_ITEM = '.carousel-item'; - var SELECTOR_ITEM_IMG = '.carousel-item img'; - var SELECTOR_NEXT_PREV = '.carousel-item-next, .carousel-item-prev'; - var SELECTOR_INDICATORS = '.carousel-indicators'; - var SELECTOR_DATA_SLIDE = '[data-slide], [data-slide-to]'; - var SELECTOR_DATA_RIDE = '[data-ride="carousel"]'; - var PointerType = { - TOUCH: 'touch', - PEN: 'pen' - }; + const ORDER_NEXT = 'next'; + const ORDER_PREV = 'prev'; + const DIRECTION_LEFT = 'left'; + const DIRECTION_RIGHT = 'right'; + const EVENT_SLIDE = `slide${EVENT_KEY$9}`; + const EVENT_SLID = `slid${EVENT_KEY$9}`; + const EVENT_KEYDOWN = `keydown${EVENT_KEY$9}`; + const EVENT_MOUSEENTER = `mouseenter${EVENT_KEY$9}`; + const EVENT_MOUSELEAVE = `mouseleave${EVENT_KEY$9}`; + const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$9}`; + const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$9}`; + const EVENT_TOUCHEND = `touchend${EVENT_KEY$9}`; + const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$9}`; + const EVENT_POINTERUP = `pointerup${EVENT_KEY$9}`; + const EVENT_DRAG_START = `dragstart${EVENT_KEY$9}`; + const EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$9}${DATA_API_KEY$6}`; + const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$9}${DATA_API_KEY$6}`; + const CLASS_NAME_CAROUSEL = 'carousel'; + const CLASS_NAME_ACTIVE$2 = 'active'; + const CLASS_NAME_SLIDE = 'slide'; + const CLASS_NAME_END = 'carousel-item-end'; + const CLASS_NAME_START = 'carousel-item-start'; + const CLASS_NAME_NEXT = 'carousel-item-next'; + const CLASS_NAME_PREV = 'carousel-item-prev'; + const CLASS_NAME_POINTER_EVENT = 'pointer-event'; + const SELECTOR_ACTIVE$1 = '.active'; + const SELECTOR_ACTIVE_ITEM = '.active.carousel-item'; + const SELECTOR_ITEM = '.carousel-item'; + const SELECTOR_ITEM_IMG = '.carousel-item img'; + const SELECTOR_NEXT_PREV = '.carousel-item-next, .carousel-item-prev'; + const SELECTOR_INDICATORS = '.carousel-indicators'; + const SELECTOR_INDICATOR = '[data-bs-target]'; + const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]'; + const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]'; + const POINTER_TYPE_TOUCH = 'touch'; + const POINTER_TYPE_PEN = 'pen'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ - var Carousel = /*#__PURE__*/function () { - function Carousel(element, config) { + class Carousel extends BaseComponent { + constructor(element, config) { + super(element); this._items = null; this._interval = null; this._activeElement = null; @@ -672,54 +1132,58 @@ this.touchStartX = 0; this.touchDeltaX = 0; this._config = this._getConfig(config); - this._element = element; - this._indicatorsElement = this._element.querySelector(SELECTOR_INDICATORS); + this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element); this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0; - this._pointerEvent = Boolean(window.PointerEvent || window.MSPointerEvent); + this._pointerEvent = Boolean(window.PointerEvent); this._addEventListeners(); } // Getters - var _proto = Carousel.prototype; + static get Default() { + return Default$9; + } - // Public - _proto.next = function next() { + static get NAME() { + return NAME$a; + } // Public + + + next() { if (!this._isSliding) { - this._slide(DIRECTION_NEXT); + this._slide(ORDER_NEXT); } - }; + } - _proto.nextWhenVisible = function nextWhenVisible() { - var $element = $__default['default'](this._element); // Don't call next when the page isn't visible + nextWhenVisible() { + // Don't call next when the page isn't visible // or the carousel or its parent isn't visible - - if (!document.hidden && $element.is(':visible') && $element.css('visibility') !== 'hidden') { + if (!document.hidden && isVisible(this._element)) { this.next(); } - }; + } - _proto.prev = function prev() { + prev() { if (!this._isSliding) { - this._slide(DIRECTION_PREV); + this._slide(ORDER_PREV); } - }; + } - _proto.pause = function pause(event) { + pause(event) { if (!event) { this._isPaused = true; } - if (this._element.querySelector(SELECTOR_NEXT_PREV)) { - Util.triggerTransitionEnd(this._element); + if (SelectorEngine.findOne(SELECTOR_NEXT_PREV, this._element)) { + triggerTransitionEnd(this._element); this.cycle(true); } clearInterval(this._interval); this._interval = null; - }; + } - _proto.cycle = function cycle(event) { + cycle(event) { if (!event) { this._isPaused = false; } @@ -729,28 +1193,24 @@ this._interval = null; } - if (this._config.interval && !this._isPaused) { + if (this._config && this._config.interval && !this._isPaused) { this._updateInterval(); this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval); } - }; - - _proto.to = function to(index) { - var _this = this; + } - this._activeElement = this._element.querySelector(SELECTOR_ACTIVE_ITEM); + to(index) { + this._activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element); - var activeIndex = this._getItemIndex(this._activeElement); + const activeIndex = this._getItemIndex(this._activeElement); if (index > this._items.length - 1 || index < 0) { return; } if (this._isSliding) { - $__default['default'](this._element).one(EVENT_SLID, function () { - return _this.to(index); - }); + EventHandler.one(this._element, EVENT_SLID, () => this.to(index)); return; } @@ -760,105 +1220,74 @@ return; } - var direction = index > activeIndex ? DIRECTION_NEXT : DIRECTION_PREV; + const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV; - this._slide(direction, this._items[index]); - }; - - _proto.dispose = function dispose() { - $__default['default'](this._element).off(EVENT_KEY$2); - $__default['default'].removeData(this._element, DATA_KEY$2); - this._items = null; - this._config = null; - this._element = null; - this._interval = null; - this._isPaused = null; - this._isSliding = null; - this._activeElement = null; - this._indicatorsElement = null; + this._slide(order, this._items[index]); } // Private - ; - _proto._getConfig = function _getConfig(config) { - config = _extends({}, Default, config); - Util.typeCheckConfig(NAME$2, config, DefaultType); + + _getConfig(config) { + config = { ...Default$9, + ...config + }; + typeCheckConfig(NAME$a, config, DefaultType$9); return config; - }; + } - _proto._handleSwipe = function _handleSwipe() { - var absDeltax = Math.abs(this.touchDeltaX); + _handleSwipe() { + const absDeltax = Math.abs(this.touchDeltaX); if (absDeltax <= SWIPE_THRESHOLD) { return; } - var direction = absDeltax / this.touchDeltaX; - this.touchDeltaX = 0; // swipe left - - if (direction > 0) { - this.prev(); - } // swipe right - + const direction = absDeltax / this.touchDeltaX; + this.touchDeltaX = 0; - if (direction < 0) { - this.next(); + if (!direction) { + return; } - }; - _proto._addEventListeners = function _addEventListeners() { - var _this2 = this; + this._slide(direction > 0 ? DIRECTION_RIGHT : DIRECTION_LEFT); + } + _addEventListeners() { if (this._config.keyboard) { - $__default['default'](this._element).on(EVENT_KEYDOWN, function (event) { - return _this2._keydown(event); - }); + EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event)); } if (this._config.pause === 'hover') { - $__default['default'](this._element).on(EVENT_MOUSEENTER, function (event) { - return _this2.pause(event); - }).on(EVENT_MOUSELEAVE, function (event) { - return _this2.cycle(event); - }); + EventHandler.on(this._element, EVENT_MOUSEENTER, event => this.pause(event)); + EventHandler.on(this._element, EVENT_MOUSELEAVE, event => this.cycle(event)); } - if (this._config.touch) { + if (this._config.touch && this._touchSupported) { this._addTouchEventListeners(); } - }; - - _proto._addTouchEventListeners = function _addTouchEventListeners() { - var _this3 = this; - - if (!this._touchSupported) { - return; - } + } - var start = function start(event) { - if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) { - _this3.touchStartX = event.originalEvent.clientX; - } else if (!_this3._pointerEvent) { - _this3.touchStartX = event.originalEvent.touches[0].clientX; + _addTouchEventListeners() { + const start = event => { + if (this._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) { + this.touchStartX = event.clientX; + } else if (!this._pointerEvent) { + this.touchStartX = event.touches[0].clientX; } }; - var move = function move(event) { + const move = event => { // ensure swiping with one touch and not pinching - if (event.originalEvent.touches && event.originalEvent.touches.length > 1) { - _this3.touchDeltaX = 0; - } else { - _this3.touchDeltaX = event.originalEvent.touches[0].clientX - _this3.touchStartX; - } + this.touchDeltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this.touchStartX; }; - var end = function end(event) { - if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) { - _this3.touchDeltaX = event.originalEvent.clientX - _this3.touchStartX; + const end = event => { + if (this._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) { + this.touchDeltaX = event.clientX - this.touchStartX; } - _this3._handleSwipe(); + this._handleSwipe(); - if (_this3._config.pause === 'hover') { + if (this._config.pause === 'hover') { // If it's a touch-enabled device, mouseenter/leave are fired as // part of the mouse compatibility events on first tap - the carousel // would stop cycling until user tapped out of it; @@ -866,121 +1295,109 @@ // (as if it's the second time we tap on it, mouseenter compat event // is NOT fired) and after a timeout (to allow for mouse compatibility // events to fire) we explicitly restart cycling - _this3.pause(); + this.pause(); - if (_this3.touchTimeout) { - clearTimeout(_this3.touchTimeout); + if (this.touchTimeout) { + clearTimeout(this.touchTimeout); } - _this3.touchTimeout = setTimeout(function (event) { - return _this3.cycle(event); - }, TOUCHEVENT_COMPAT_WAIT + _this3._config.interval); + this.touchTimeout = setTimeout(event => this.cycle(event), TOUCHEVENT_COMPAT_WAIT + this._config.interval); } }; - $__default['default'](this._element.querySelectorAll(SELECTOR_ITEM_IMG)).on(EVENT_DRAG_START, function (e) { - return e.preventDefault(); + SelectorEngine.find(SELECTOR_ITEM_IMG, this._element).forEach(itemImg => { + EventHandler.on(itemImg, EVENT_DRAG_START, e => e.preventDefault()); }); if (this._pointerEvent) { - $__default['default'](this._element).on(EVENT_POINTERDOWN, function (event) { - return start(event); - }); - $__default['default'](this._element).on(EVENT_POINTERUP, function (event) { - return end(event); - }); + EventHandler.on(this._element, EVENT_POINTERDOWN, event => start(event)); + EventHandler.on(this._element, EVENT_POINTERUP, event => end(event)); this._element.classList.add(CLASS_NAME_POINTER_EVENT); } else { - $__default['default'](this._element).on(EVENT_TOUCHSTART, function (event) { - return start(event); - }); - $__default['default'](this._element).on(EVENT_TOUCHMOVE, function (event) { - return move(event); - }); - $__default['default'](this._element).on(EVENT_TOUCHEND, function (event) { - return end(event); - }); + EventHandler.on(this._element, EVENT_TOUCHSTART, event => start(event)); + EventHandler.on(this._element, EVENT_TOUCHMOVE, event => move(event)); + EventHandler.on(this._element, EVENT_TOUCHEND, event => end(event)); } - }; + } - _proto._keydown = function _keydown(event) { + _keydown(event) { if (/input|textarea/i.test(event.target.tagName)) { return; } - switch (event.which) { - case ARROW_LEFT_KEYCODE: - event.preventDefault(); - this.prev(); - break; + if (event.key === ARROW_LEFT_KEY) { + event.preventDefault(); - case ARROW_RIGHT_KEYCODE: - event.preventDefault(); - this.next(); - break; + this._slide(DIRECTION_RIGHT); + } else if (event.key === ARROW_RIGHT_KEY) { + event.preventDefault(); + + this._slide(DIRECTION_LEFT); } - }; + } - _proto._getItemIndex = function _getItemIndex(element) { - this._items = element && element.parentNode ? [].slice.call(element.parentNode.querySelectorAll(SELECTOR_ITEM)) : []; + _getItemIndex(element) { + this._items = element && element.parentNode ? SelectorEngine.find(SELECTOR_ITEM, element.parentNode) : []; return this._items.indexOf(element); - }; + } - _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) { - var isNextDirection = direction === DIRECTION_NEXT; - var isPrevDirection = direction === DIRECTION_PREV; + _getItemByOrder(order, activeElement) { + const isNext = order === ORDER_NEXT; + const isPrev = order === ORDER_PREV; - var activeIndex = this._getItemIndex(activeElement); + const activeIndex = this._getItemIndex(activeElement); - var lastItemIndex = this._items.length - 1; - var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex; + const lastItemIndex = this._items.length - 1; + const isGoingToWrap = isPrev && activeIndex === 0 || isNext && activeIndex === lastItemIndex; if (isGoingToWrap && !this._config.wrap) { return activeElement; } - var delta = direction === DIRECTION_PREV ? -1 : 1; - var itemIndex = (activeIndex + delta) % this._items.length; + const delta = isPrev ? -1 : 1; + const itemIndex = (activeIndex + delta) % this._items.length; return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex]; - }; + } - _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) { - var targetIndex = this._getItemIndex(relatedTarget); + _triggerSlideEvent(relatedTarget, eventDirectionName) { + const targetIndex = this._getItemIndex(relatedTarget); - var fromIndex = this._getItemIndex(this._element.querySelector(SELECTOR_ACTIVE_ITEM)); + const fromIndex = this._getItemIndex(SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element)); - var slideEvent = $__default['default'].Event(EVENT_SLIDE, { - relatedTarget: relatedTarget, + return EventHandler.trigger(this._element, EVENT_SLIDE, { + relatedTarget, direction: eventDirectionName, from: fromIndex, to: targetIndex }); - $__default['default'](this._element).trigger(slideEvent); - return slideEvent; - }; + } - _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) { + _setActiveIndicatorElement(element) { if (this._indicatorsElement) { - var indicators = [].slice.call(this._indicatorsElement.querySelectorAll(SELECTOR_ACTIVE$1)); - $__default['default'](indicators).removeClass(CLASS_NAME_ACTIVE$1); - - var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)]; - - if (nextIndicator) { - $__default['default'](nextIndicator).addClass(CLASS_NAME_ACTIVE$1); + const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE$1, this._indicatorsElement); + activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2); + activeIndicator.removeAttribute('aria-current'); + const indicators = SelectorEngine.find(SELECTOR_INDICATOR, this._indicatorsElement); + + for (let i = 0; i < indicators.length; i++) { + if (Number.parseInt(indicators[i].getAttribute('data-bs-slide-to'), 10) === this._getItemIndex(element)) { + indicators[i].classList.add(CLASS_NAME_ACTIVE$2); + indicators[i].setAttribute('aria-current', 'true'); + break; + } } } - }; + } - _proto._updateInterval = function _updateInterval() { - var element = this._activeElement || this._element.querySelector(SELECTOR_ACTIVE_ITEM); + _updateInterval() { + const element = this._activeElement || SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element); if (!element) { return; } - var elementInterval = parseInt(element.getAttribute('data-interval'), 10); + const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10); if (elementInterval) { this._config.defaultInterval = this._config.defaultInterval || this._config.interval; @@ -988,42 +1405,34 @@ } else { this._config.interval = this._config.defaultInterval || this._config.interval; } - }; + } - _proto._slide = function _slide(direction, element) { - var _this4 = this; + _slide(directionOrOrder, element) { + const order = this._directionToOrder(directionOrOrder); - var activeElement = this._element.querySelector(SELECTOR_ACTIVE_ITEM); + const activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element); - var activeElementIndex = this._getItemIndex(activeElement); + const activeElementIndex = this._getItemIndex(activeElement); - var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement); + const nextElement = element || this._getItemByOrder(order, activeElement); - var nextElementIndex = this._getItemIndex(nextElement); + const nextElementIndex = this._getItemIndex(nextElement); - var isCycling = Boolean(this._interval); - var directionalClassName; - var orderClassName; - var eventDirectionName; + const isCycling = Boolean(this._interval); + const isNext = order === ORDER_NEXT; + const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END; + const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV; - if (direction === DIRECTION_NEXT) { - directionalClassName = CLASS_NAME_LEFT; - orderClassName = CLASS_NAME_NEXT; - eventDirectionName = DIRECTION_LEFT; - } else { - directionalClassName = CLASS_NAME_RIGHT; - orderClassName = CLASS_NAME_PREV; - eventDirectionName = DIRECTION_RIGHT; - } + const eventDirectionName = this._orderToDirection(order); - if (nextElement && $__default['default'](nextElement).hasClass(CLASS_NAME_ACTIVE$1)) { + if (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE$2)) { this._isSliding = false; return; } - var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName); + const slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName); - if (slideEvent.isDefaultPrevented()) { + if (slideEvent.defaultPrevented) { return; } @@ -1041,116 +1450,132 @@ this._setActiveIndicatorElement(nextElement); this._activeElement = nextElement; - var slidEvent = $__default['default'].Event(EVENT_SLID, { - relatedTarget: nextElement, - direction: eventDirectionName, - from: activeElementIndex, - to: nextElementIndex - }); - if ($__default['default'](this._element).hasClass(CLASS_NAME_SLIDE)) { - $__default['default'](nextElement).addClass(orderClassName); - Util.reflow(nextElement); - $__default['default'](activeElement).addClass(directionalClassName); - $__default['default'](nextElement).addClass(directionalClassName); - var transitionDuration = Util.getTransitionDurationFromElement(activeElement); - $__default['default'](activeElement).one(Util.TRANSITION_END, function () { - $__default['default'](nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(CLASS_NAME_ACTIVE$1); - $__default['default'](activeElement).removeClass(CLASS_NAME_ACTIVE$1 + " " + orderClassName + " " + directionalClassName); - _this4._isSliding = false; - setTimeout(function () { - return $__default['default'](_this4._element).trigger(slidEvent); - }, 0); - }).emulateTransitionEnd(transitionDuration); + const triggerSlidEvent = () => { + EventHandler.trigger(this._element, EVENT_SLID, { + relatedTarget: nextElement, + direction: eventDirectionName, + from: activeElementIndex, + to: nextElementIndex + }); + }; + + if (this._element.classList.contains(CLASS_NAME_SLIDE)) { + nextElement.classList.add(orderClassName); + reflow(nextElement); + activeElement.classList.add(directionalClassName); + nextElement.classList.add(directionalClassName); + + const completeCallBack = () => { + nextElement.classList.remove(directionalClassName, orderClassName); + nextElement.classList.add(CLASS_NAME_ACTIVE$2); + activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName); + this._isSliding = false; + setTimeout(triggerSlidEvent, 0); + }; + + this._queueCallback(completeCallBack, activeElement, true); } else { - $__default['default'](activeElement).removeClass(CLASS_NAME_ACTIVE$1); - $__default['default'](nextElement).addClass(CLASS_NAME_ACTIVE$1); + activeElement.classList.remove(CLASS_NAME_ACTIVE$2); + nextElement.classList.add(CLASS_NAME_ACTIVE$2); this._isSliding = false; - $__default['default'](this._element).trigger(slidEvent); + triggerSlidEvent(); } if (isCycling) { this.cycle(); } - } // Static - ; + } - Carousel._jQueryInterface = function _jQueryInterface(config) { - return this.each(function () { - var data = $__default['default'](this).data(DATA_KEY$2); + _directionToOrder(direction) { + if (![DIRECTION_RIGHT, DIRECTION_LEFT].includes(direction)) { + return direction; + } - var _config = _extends({}, Default, $__default['default'](this).data()); + if (isRTL()) { + return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT; + } - if (typeof config === 'object') { - _config = _extends({}, _config, config); - } + return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV; + } - var action = typeof config === 'string' ? config : _config.slide; + _orderToDirection(order) { + if (![ORDER_NEXT, ORDER_PREV].includes(order)) { + return order; + } - if (!data) { - data = new Carousel(this, _config); - $__default['default'](this).data(DATA_KEY$2, data); - } + if (isRTL()) { + return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT; + } - if (typeof config === 'number') { - data.to(config); - } else if (typeof action === 'string') { - if (typeof data[action] === 'undefined') { - throw new TypeError("No method named \"" + action + "\""); - } + return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT; + } // Static - data[action](); - } else if (_config.interval && _config.ride) { - data.pause(); - data.cycle(); - } - }); - }; - Carousel._dataApiClickHandler = function _dataApiClickHandler(event) { - var selector = Util.getSelectorFromElement(this); + static carouselInterface(element, config) { + let data = Data.get(element, DATA_KEY$9); + let _config = { ...Default$9, + ...Manipulator.getDataAttributes(element) + }; - if (!selector) { - return; + if (typeof config === 'object') { + _config = { ..._config, + ...config + }; } - var target = $__default['default'](selector)[0]; + const action = typeof config === 'string' ? config : _config.slide; - if (!target || !$__default['default'](target).hasClass(CLASS_NAME_CAROUSEL)) { - return; + if (!data) { + data = new Carousel(element, _config); } - var config = _extends({}, $__default['default'](target).data(), $__default['default'](this).data()); + if (typeof config === 'number') { + data.to(config); + } else if (typeof action === 'string') { + if (typeof data[action] === 'undefined') { + throw new TypeError(`No method named "${action}"`); + } + + data[action](); + } else if (_config.interval && _config.ride) { + data.pause(); + data.cycle(); + } + } + + static jQueryInterface(config) { + return this.each(function () { + Carousel.carouselInterface(this, config); + }); + } + + static dataApiClickHandler(event) { + const target = getElementFromSelector(this); + + if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) { + return; + } - var slideIndex = this.getAttribute('data-slide-to'); + const config = { ...Manipulator.getDataAttributes(target), + ...Manipulator.getDataAttributes(this) + }; + const slideIndex = this.getAttribute('data-bs-slide-to'); if (slideIndex) { config.interval = false; } - Carousel._jQueryInterface.call($__default['default'](target), config); + Carousel.carouselInterface(target, config); if (slideIndex) { - $__default['default'](target).data(DATA_KEY$2).to(slideIndex); + Data.get(target, DATA_KEY$9).to(slideIndex); } event.preventDefault(); - }; - - _createClass(Carousel, null, [{ - key: "VERSION", - get: function get() { - return VERSION$2; - } - }, { - key: "Default", - get: function get() { - return Default; - } - }]); + } - return Carousel; - }(); + } /** * ------------------------------------------------------------------------ * Data Api implementation @@ -1158,85 +1583,80 @@ */ - $__default['default'](document).on(EVENT_CLICK_DATA_API$2, SELECTOR_DATA_SLIDE, Carousel._dataApiClickHandler); - $__default['default'](window).on(EVENT_LOAD_DATA_API$1, function () { - var carousels = [].slice.call(document.querySelectorAll(SELECTOR_DATA_RIDE)); - - for (var i = 0, len = carousels.length; i < len; i++) { - var $carousel = $__default['default'](carousels[i]); + EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, Carousel.dataApiClickHandler); + EventHandler.on(window, EVENT_LOAD_DATA_API$2, () => { + const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE); - Carousel._jQueryInterface.call($carousel, $carousel.data()); + for (let i = 0, len = carousels.length; i < len; i++) { + Carousel.carouselInterface(carousels[i], Data.get(carousels[i], DATA_KEY$9)); } }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ + * add .Carousel to jQuery only if jQuery is present */ - $__default['default'].fn[NAME$2] = Carousel._jQueryInterface; - $__default['default'].fn[NAME$2].Constructor = Carousel; - - $__default['default'].fn[NAME$2].noConflict = function () { - $__default['default'].fn[NAME$2] = JQUERY_NO_CONFLICT$2; - return Carousel._jQueryInterface; - }; + defineJQueryPlugin(Carousel); /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): collapse.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ - var NAME$3 = 'collapse'; - var VERSION$3 = '4.6.0'; - var DATA_KEY$3 = 'bs.collapse'; - var EVENT_KEY$3 = "." + DATA_KEY$3; - var DATA_API_KEY$3 = '.data-api'; - var JQUERY_NO_CONFLICT$3 = $__default['default'].fn[NAME$3]; - var Default$1 = { + const NAME$9 = 'collapse'; + const DATA_KEY$8 = 'bs.collapse'; + const EVENT_KEY$8 = `.${DATA_KEY$8}`; + const DATA_API_KEY$5 = '.data-api'; + const Default$8 = { toggle: true, parent: '' }; - var DefaultType$1 = { + const DefaultType$8 = { toggle: 'boolean', parent: '(string|element)' }; - var EVENT_SHOW = "show" + EVENT_KEY$3; - var EVENT_SHOWN = "shown" + EVENT_KEY$3; - var EVENT_HIDE = "hide" + EVENT_KEY$3; - var EVENT_HIDDEN = "hidden" + EVENT_KEY$3; - var EVENT_CLICK_DATA_API$3 = "click" + EVENT_KEY$3 + DATA_API_KEY$3; - var CLASS_NAME_SHOW$1 = 'show'; - var CLASS_NAME_COLLAPSE = 'collapse'; - var CLASS_NAME_COLLAPSING = 'collapsing'; - var CLASS_NAME_COLLAPSED = 'collapsed'; - var DIMENSION_WIDTH = 'width'; - var DIMENSION_HEIGHT = 'height'; - var SELECTOR_ACTIVES = '.show, .collapsing'; - var SELECTOR_DATA_TOGGLE$1 = '[data-toggle="collapse"]'; + const EVENT_SHOW$5 = `show${EVENT_KEY$8}`; + const EVENT_SHOWN$5 = `shown${EVENT_KEY$8}`; + const EVENT_HIDE$5 = `hide${EVENT_KEY$8}`; + const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$8}`; + const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`; + const CLASS_NAME_SHOW$8 = 'show'; + const CLASS_NAME_COLLAPSE = 'collapse'; + const CLASS_NAME_COLLAPSING = 'collapsing'; + const CLASS_NAME_COLLAPSED = 'collapsed'; + const WIDTH = 'width'; + const HEIGHT = 'height'; + const SELECTOR_ACTIVES = '.show, .collapsing'; + const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ - var Collapse = /*#__PURE__*/function () { - function Collapse(element, config) { + class Collapse extends BaseComponent { + constructor(element, config) { + super(element); this._isTransitioning = false; - this._element = element; this._config = this._getConfig(config); - this._triggerArray = [].slice.call(document.querySelectorAll("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]"))); - var toggleList = [].slice.call(document.querySelectorAll(SELECTOR_DATA_TOGGLE$1)); - - for (var i = 0, len = toggleList.length; i < len; i++) { - var elem = toggleList[i]; - var selector = Util.getSelectorFromElement(elem); - var filterElement = [].slice.call(document.querySelectorAll(selector)).filter(function (foundElem) { - return foundElem === element; - }); + this._triggerArray = SelectorEngine.find(`${SELECTOR_DATA_TOGGLE$4}[href="#${this._element.id}"],` + `${SELECTOR_DATA_TOGGLE$4}[data-bs-target="#${this._element.id}"]`); + const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4); + + for (let i = 0, len = toggleList.length; i < len; i++) { + const elem = toggleList[i]; + const selector = getSelectorFromElement(elem); + const filterElement = SelectorEngine.find(selector).filter(foundElem => foundElem === this._element); - if (selector !== null && filterElement.length > 0) { + if (selector !== null && filterElement.length) { this._selector = selector; this._triggerArray.push(elem); @@ -1255,31 +1675,35 @@ } // Getters - var _proto = Collapse.prototype; + static get Default() { + return Default$8; + } - // Public - _proto.toggle = function toggle() { - if ($__default['default'](this._element).hasClass(CLASS_NAME_SHOW$1)) { + static get NAME() { + return NAME$9; + } // Public + + + toggle() { + if (this._element.classList.contains(CLASS_NAME_SHOW$8)) { this.hide(); } else { this.show(); } - }; - - _proto.show = function show() { - var _this = this; + } - if (this._isTransitioning || $__default['default'](this._element).hasClass(CLASS_NAME_SHOW$1)) { + show() { + if (this._isTransitioning || this._element.classList.contains(CLASS_NAME_SHOW$8)) { return; } - var actives; - var activesData; + let actives; + let activesData; if (this._parent) { - actives = [].slice.call(this._parent.querySelectorAll(SELECTOR_ACTIVES)).filter(function (elem) { - if (typeof _this._config.parent === 'string') { - return elem.getAttribute('data-parent') === _this._config.parent; + actives = SelectorEngine.find(SELECTOR_ACTIVES, this._parent).filter(elem => { + if (typeof this._config.parent === 'string') { + return elem.getAttribute('data-bs-parent') === this._config.parent; } return elem.classList.contains(CLASS_NAME_COLLAPSE); @@ -1290,209 +1714,203 @@ } } + const container = SelectorEngine.findOne(this._selector); + if (actives) { - activesData = $__default['default'](actives).not(this._selector).data(DATA_KEY$3); + const tempActiveData = actives.find(elem => container !== elem); + activesData = tempActiveData ? Data.get(tempActiveData, DATA_KEY$8) : null; if (activesData && activesData._isTransitioning) { return; } } - var startEvent = $__default['default'].Event(EVENT_SHOW); - $__default['default'](this._element).trigger(startEvent); + const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$5); - if (startEvent.isDefaultPrevented()) { + if (startEvent.defaultPrevented) { return; } if (actives) { - Collapse._jQueryInterface.call($__default['default'](actives).not(this._selector), 'hide'); + actives.forEach(elemActive => { + if (container !== elemActive) { + Collapse.collapseInterface(elemActive, 'hide'); + } - if (!activesData) { - $__default['default'](actives).data(DATA_KEY$3, null); - } + if (!activesData) { + Data.set(elemActive, DATA_KEY$8, null); + } + }); } - var dimension = this._getDimension(); + const dimension = this._getDimension(); + + this._element.classList.remove(CLASS_NAME_COLLAPSE); + + this._element.classList.add(CLASS_NAME_COLLAPSING); - $__default['default'](this._element).removeClass(CLASS_NAME_COLLAPSE).addClass(CLASS_NAME_COLLAPSING); this._element.style[dimension] = 0; if (this._triggerArray.length) { - $__default['default'](this._triggerArray).removeClass(CLASS_NAME_COLLAPSED).attr('aria-expanded', true); + this._triggerArray.forEach(element => { + element.classList.remove(CLASS_NAME_COLLAPSED); + element.setAttribute('aria-expanded', true); + }); } this.setTransitioning(true); - var complete = function complete() { - $__default['default'](_this._element).removeClass(CLASS_NAME_COLLAPSING).addClass(CLASS_NAME_COLLAPSE + " " + CLASS_NAME_SHOW$1); - _this._element.style[dimension] = ''; + const complete = () => { + this._element.classList.remove(CLASS_NAME_COLLAPSING); - _this.setTransitioning(false); + this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$8); - $__default['default'](_this._element).trigger(EVENT_SHOWN); + this._element.style[dimension] = ''; + this.setTransitioning(false); + EventHandler.trigger(this._element, EVENT_SHOWN$5); }; - var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1); - var scrollSize = "scroll" + capitalizedDimension; - var transitionDuration = Util.getTransitionDurationFromElement(this._element); - $__default['default'](this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); - this._element.style[dimension] = this._element[scrollSize] + "px"; - }; + const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1); + const scrollSize = `scroll${capitalizedDimension}`; + + this._queueCallback(complete, this._element, true); - _proto.hide = function hide() { - var _this2 = this; + this._element.style[dimension] = `${this._element[scrollSize]}px`; + } - if (this._isTransitioning || !$__default['default'](this._element).hasClass(CLASS_NAME_SHOW$1)) { + hide() { + if (this._isTransitioning || !this._element.classList.contains(CLASS_NAME_SHOW$8)) { return; } - var startEvent = $__default['default'].Event(EVENT_HIDE); - $__default['default'](this._element).trigger(startEvent); + const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$5); - if (startEvent.isDefaultPrevented()) { + if (startEvent.defaultPrevented) { return; } - var dimension = this._getDimension(); + const dimension = this._getDimension(); - this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px"; - Util.reflow(this._element); - $__default['default'](this._element).addClass(CLASS_NAME_COLLAPSING).removeClass(CLASS_NAME_COLLAPSE + " " + CLASS_NAME_SHOW$1); - var triggerArrayLength = this._triggerArray.length; + this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`; + reflow(this._element); - if (triggerArrayLength > 0) { - for (var i = 0; i < triggerArrayLength; i++) { - var trigger = this._triggerArray[i]; - var selector = Util.getSelectorFromElement(trigger); + this._element.classList.add(CLASS_NAME_COLLAPSING); - if (selector !== null) { - var $elem = $__default['default']([].slice.call(document.querySelectorAll(selector))); + this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$8); - if (!$elem.hasClass(CLASS_NAME_SHOW$1)) { - $__default['default'](trigger).addClass(CLASS_NAME_COLLAPSED).attr('aria-expanded', false); - } + const triggerArrayLength = this._triggerArray.length; + + if (triggerArrayLength > 0) { + for (let i = 0; i < triggerArrayLength; i++) { + const trigger = this._triggerArray[i]; + const elem = getElementFromSelector(trigger); + + if (elem && !elem.classList.contains(CLASS_NAME_SHOW$8)) { + trigger.classList.add(CLASS_NAME_COLLAPSED); + trigger.setAttribute('aria-expanded', false); } } } this.setTransitioning(true); - var complete = function complete() { - _this2.setTransitioning(false); + const complete = () => { + this.setTransitioning(false); + + this._element.classList.remove(CLASS_NAME_COLLAPSING); - $__default['default'](_this2._element).removeClass(CLASS_NAME_COLLAPSING).addClass(CLASS_NAME_COLLAPSE).trigger(EVENT_HIDDEN); + this._element.classList.add(CLASS_NAME_COLLAPSE); + + EventHandler.trigger(this._element, EVENT_HIDDEN$5); }; this._element.style[dimension] = ''; - var transitionDuration = Util.getTransitionDurationFromElement(this._element); - $__default['default'](this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); - }; - _proto.setTransitioning = function setTransitioning(isTransitioning) { - this._isTransitioning = isTransitioning; - }; + this._queueCallback(complete, this._element, true); + } - _proto.dispose = function dispose() { - $__default['default'].removeData(this._element, DATA_KEY$3); - this._config = null; - this._parent = null; - this._element = null; - this._triggerArray = null; - this._isTransitioning = null; + setTransitioning(isTransitioning) { + this._isTransitioning = isTransitioning; } // Private - ; - _proto._getConfig = function _getConfig(config) { - config = _extends({}, Default$1, config); + + _getConfig(config) { + config = { ...Default$8, + ...config + }; config.toggle = Boolean(config.toggle); // Coerce string values - Util.typeCheckConfig(NAME$3, config, DefaultType$1); + typeCheckConfig(NAME$9, config, DefaultType$8); return config; - }; + } - _proto._getDimension = function _getDimension() { - var hasWidth = $__default['default'](this._element).hasClass(DIMENSION_WIDTH); - return hasWidth ? DIMENSION_WIDTH : DIMENSION_HEIGHT; - }; + _getDimension() { + return this._element.classList.contains(WIDTH) ? WIDTH : HEIGHT; + } - _proto._getParent = function _getParent() { - var _this3 = this; + _getParent() { + let { + parent + } = this._config; + parent = getElement(parent); + const selector = `${SELECTOR_DATA_TOGGLE$4}[data-bs-parent="${parent}"]`; + SelectorEngine.find(selector, parent).forEach(element => { + const selected = getElementFromSelector(element); - var parent; + this._addAriaAndCollapsedClass(selected, [element]); + }); + return parent; + } - if (Util.isElement(this._config.parent)) { - parent = this._config.parent; // It's a jQuery object + _addAriaAndCollapsedClass(element, triggerArray) { + if (!element || !triggerArray.length) { + return; + } - if (typeof this._config.parent.jquery !== 'undefined') { - parent = this._config.parent[0]; + const isOpen = element.classList.contains(CLASS_NAME_SHOW$8); + triggerArray.forEach(elem => { + if (isOpen) { + elem.classList.remove(CLASS_NAME_COLLAPSED); + } else { + elem.classList.add(CLASS_NAME_COLLAPSED); } - } else { - parent = document.querySelector(this._config.parent); - } - var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]"; - var children = [].slice.call(parent.querySelectorAll(selector)); - $__default['default'](children).each(function (i, element) { - _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]); + elem.setAttribute('aria-expanded', isOpen); }); - return parent; - }; - - _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) { - var isOpen = $__default['default'](element).hasClass(CLASS_NAME_SHOW$1); - - if (triggerArray.length) { - $__default['default'](triggerArray).toggleClass(CLASS_NAME_COLLAPSED, !isOpen).attr('aria-expanded', isOpen); - } } // Static - ; - Collapse._getTargetFromElement = function _getTargetFromElement(element) { - var selector = Util.getSelectorFromElement(element); - return selector ? document.querySelector(selector) : null; - }; - Collapse._jQueryInterface = function _jQueryInterface(config) { - return this.each(function () { - var $element = $__default['default'](this); - var data = $element.data(DATA_KEY$3); + static collapseInterface(element, config) { + let data = Data.get(element, DATA_KEY$8); + const _config = { ...Default$8, + ...Manipulator.getDataAttributes(element), + ...(typeof config === 'object' && config ? config : {}) + }; - var _config = _extends({}, Default$1, $element.data(), typeof config === 'object' && config ? config : {}); + if (!data && _config.toggle && typeof config === 'string' && /show|hide/.test(config)) { + _config.toggle = false; + } - if (!data && _config.toggle && typeof config === 'string' && /show|hide/.test(config)) { - _config.toggle = false; - } + if (!data) { + data = new Collapse(element, _config); + } - if (!data) { - data = new Collapse(this, _config); - $element.data(DATA_KEY$3, data); + if (typeof config === 'string') { + if (typeof data[config] === 'undefined') { + throw new TypeError(`No method named "${config}"`); } - if (typeof config === 'string') { - if (typeof data[config] === 'undefined') { - throw new TypeError("No method named \"" + config + "\""); - } + data[config](); + } + } - data[config](); - } + static jQueryInterface(config) { + return this.each(function () { + Collapse.collapseInterface(this, config); }); - }; - - _createClass(Collapse, null, [{ - key: "VERSION", - get: function get() { - return VERSION$3; - } - }, { - key: "Default", - get: function get() { - return Default$1; - } - }]); + } - return Collapse; - }(); + } /** * ------------------------------------------------------------------------ * Data Api implementation @@ -1500,103 +1918,105 @@ */ - $__default['default'](document).on(EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$1, function (event) { + EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) { // preventDefault only for <a> elements (which change the URL) not inside the collapsible element - if (event.currentTarget.tagName === 'A') { + if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') { event.preventDefault(); } - var $trigger = $__default['default'](this); - var selector = Util.getSelectorFromElement(this); - var selectors = [].slice.call(document.querySelectorAll(selector)); - $__default['default'](selectors).each(function () { - var $target = $__default['default'](this); - var data = $target.data(DATA_KEY$3); - var config = data ? 'toggle' : $trigger.data(); + const triggerData = Manipulator.getDataAttributes(this); + const selector = getSelectorFromElement(this); + const selectorElements = SelectorEngine.find(selector); + selectorElements.forEach(element => { + const data = Data.get(element, DATA_KEY$8); + let config; + + if (data) { + // update parent attribute + if (data._parent === null && typeof triggerData.parent === 'string') { + data._config.parent = triggerData.parent; + data._parent = data._getParent(); + } + + config = 'toggle'; + } else { + config = triggerData; + } - Collapse._jQueryInterface.call($target, config); + Collapse.collapseInterface(element, config); }); }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ + * add .Collapse to jQuery only if jQuery is present */ - $__default['default'].fn[NAME$3] = Collapse._jQueryInterface; - $__default['default'].fn[NAME$3].Constructor = Collapse; - - $__default['default'].fn[NAME$3].noConflict = function () { - $__default['default'].fn[NAME$3] = JQUERY_NO_CONFLICT$3; - return Collapse._jQueryInterface; - }; + defineJQueryPlugin(Collapse); /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): dropdown.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ - var NAME$4 = 'dropdown'; - var VERSION$4 = '4.6.0'; - var DATA_KEY$4 = 'bs.dropdown'; - var EVENT_KEY$4 = "." + DATA_KEY$4; - var DATA_API_KEY$4 = '.data-api'; - var JQUERY_NO_CONFLICT$4 = $__default['default'].fn[NAME$4]; - var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key - - var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key - - var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key - - var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key - - var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key - - var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse) - - var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE); - var EVENT_HIDE$1 = "hide" + EVENT_KEY$4; - var EVENT_HIDDEN$1 = "hidden" + EVENT_KEY$4; - var EVENT_SHOW$1 = "show" + EVENT_KEY$4; - var EVENT_SHOWN$1 = "shown" + EVENT_KEY$4; - var EVENT_CLICK = "click" + EVENT_KEY$4; - var EVENT_CLICK_DATA_API$4 = "click" + EVENT_KEY$4 + DATA_API_KEY$4; - var EVENT_KEYDOWN_DATA_API = "keydown" + EVENT_KEY$4 + DATA_API_KEY$4; - var EVENT_KEYUP_DATA_API = "keyup" + EVENT_KEY$4 + DATA_API_KEY$4; - var CLASS_NAME_DISABLED = 'disabled'; - var CLASS_NAME_SHOW$2 = 'show'; - var CLASS_NAME_DROPUP = 'dropup'; - var CLASS_NAME_DROPRIGHT = 'dropright'; - var CLASS_NAME_DROPLEFT = 'dropleft'; - var CLASS_NAME_MENURIGHT = 'dropdown-menu-right'; - var CLASS_NAME_POSITION_STATIC = 'position-static'; - var SELECTOR_DATA_TOGGLE$2 = '[data-toggle="dropdown"]'; - var SELECTOR_FORM_CHILD = '.dropdown form'; - var SELECTOR_MENU = '.dropdown-menu'; - var SELECTOR_NAVBAR_NAV = '.navbar-nav'; - var SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'; - var PLACEMENT_TOP = 'top-start'; - var PLACEMENT_TOPEND = 'top-end'; - var PLACEMENT_BOTTOM = 'bottom-start'; - var PLACEMENT_BOTTOMEND = 'bottom-end'; - var PLACEMENT_RIGHT = 'right-start'; - var PLACEMENT_LEFT = 'left-start'; - var Default$2 = { - offset: 0, - flip: true, - boundary: 'scrollParent', + const NAME$8 = 'dropdown'; + const DATA_KEY$7 = 'bs.dropdown'; + const EVENT_KEY$7 = `.${DATA_KEY$7}`; + const DATA_API_KEY$4 = '.data-api'; + const ESCAPE_KEY$2 = 'Escape'; + const SPACE_KEY = 'Space'; + const TAB_KEY = 'Tab'; + const ARROW_UP_KEY = 'ArrowUp'; + const ARROW_DOWN_KEY = 'ArrowDown'; + const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button + + const REGEXP_KEYDOWN = new RegExp(`${ARROW_UP_KEY}|${ARROW_DOWN_KEY}|${ESCAPE_KEY$2}`); + const EVENT_HIDE$4 = `hide${EVENT_KEY$7}`; + const EVENT_HIDDEN$4 = `hidden${EVENT_KEY$7}`; + const EVENT_SHOW$4 = `show${EVENT_KEY$7}`; + const EVENT_SHOWN$4 = `shown${EVENT_KEY$7}`; + const EVENT_CLICK = `click${EVENT_KEY$7}`; + const EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`; + const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$7}${DATA_API_KEY$4}`; + const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$7}${DATA_API_KEY$4}`; + const CLASS_NAME_SHOW$7 = 'show'; + const CLASS_NAME_DROPUP = 'dropup'; + const CLASS_NAME_DROPEND = 'dropend'; + const CLASS_NAME_DROPSTART = 'dropstart'; + const CLASS_NAME_NAVBAR = 'navbar'; + const SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="dropdown"]'; + const SELECTOR_MENU = '.dropdown-menu'; + const SELECTOR_NAVBAR_NAV = '.navbar-nav'; + const SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'; + const PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start'; + const PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end'; + const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start'; + const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end'; + const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start'; + const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start'; + const Default$7 = { + offset: [0, 2], + boundary: 'clippingParents', reference: 'toggle', display: 'dynamic', - popperConfig: null + popperConfig: null, + autoClose: true }; - var DefaultType$2 = { - offset: '(number|string|function)', - flip: 'boolean', + const DefaultType$7 = { + offset: '(array|string|function)', boundary: '(string|element)', - reference: '(string|element)', + reference: '(string|element|object)', display: 'string', - popperConfig: '(null|object)' + popperConfig: '(null|object|function)', + autoClose: '(boolean|string)' }; /** * ------------------------------------------------------------------------ @@ -1604,9 +2024,9 @@ * ------------------------------------------------------------------------ */ - var Dropdown = /*#__PURE__*/function () { - function Dropdown(element, config) { - this._element = element; + class Dropdown extends BaseComponent { + constructor(element, config) { + super(element); this._popper = null; this._config = this._getConfig(config); this._menu = this._getMenuElement(); @@ -1616,325 +2036,344 @@ } // Getters - var _proto = Dropdown.prototype; + static get Default() { + return Default$7; + } - // Public - _proto.toggle = function toggle() { - if (this._element.disabled || $__default['default'](this._element).hasClass(CLASS_NAME_DISABLED)) { - return; - } + static get DefaultType() { + return DefaultType$7; + } - var isActive = $__default['default'](this._menu).hasClass(CLASS_NAME_SHOW$2); + static get NAME() { + return NAME$8; + } // Public - Dropdown._clearMenus(); - if (isActive) { + toggle() { + if (isDisabled(this._element)) { return; } - this.show(true); - }; + const isActive = this._element.classList.contains(CLASS_NAME_SHOW$7); - _proto.show = function show(usePopper) { - if (usePopper === void 0) { - usePopper = false; + if (isActive) { + this.hide(); + return; } - if (this._element.disabled || $__default['default'](this._element).hasClass(CLASS_NAME_DISABLED) || $__default['default'](this._menu).hasClass(CLASS_NAME_SHOW$2)) { + this.show(); + } + + show() { + if (isDisabled(this._element) || this._menu.classList.contains(CLASS_NAME_SHOW$7)) { return; } - var relatedTarget = { + const parent = Dropdown.getParentFromElement(this._element); + const relatedTarget = { relatedTarget: this._element }; - var showEvent = $__default['default'].Event(EVENT_SHOW$1, relatedTarget); - - var parent = Dropdown._getParentFromElement(this._element); + const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, relatedTarget); - $__default['default'](parent).trigger(showEvent); - - if (showEvent.isDefaultPrevented()) { + if (showEvent.defaultPrevented) { return; } // Totally disable Popper for Dropdowns in Navbar - if (!this._inNavbar && usePopper) { - /** - * Check for Popper dependency - * Popper - https://popper.js.org - */ - if (typeof Popper__default['default'] === 'undefined') { + if (this._inNavbar) { + Manipulator.setDataAttribute(this._menu, 'popper', 'none'); + } else { + if (typeof Popper__namespace === 'undefined') { throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)'); } - var referenceElement = this._element; + let referenceElement = this._element; if (this._config.reference === 'parent') { referenceElement = parent; - } else if (Util.isElement(this._config.reference)) { - referenceElement = this._config.reference; // Check if it's jQuery element + } else if (isElement(this._config.reference)) { + referenceElement = getElement(this._config.reference); + } else if (typeof this._config.reference === 'object') { + referenceElement = this._config.reference; + } - if (typeof this._config.reference.jquery !== 'undefined') { - referenceElement = this._config.reference[0]; - } - } // If boundary is not `scrollParent`, then set position to `static` - // to allow the menu to "escape" the scroll parent's boundaries - // https://github.com/twbs/bootstrap/issues/24251 + const popperConfig = this._getPopperConfig(); + const isDisplayStatic = popperConfig.modifiers.find(modifier => modifier.name === 'applyStyles' && modifier.enabled === false); + this._popper = Popper__namespace.createPopper(referenceElement, this._menu, popperConfig); - if (this._config.boundary !== 'scrollParent') { - $__default['default'](parent).addClass(CLASS_NAME_POSITION_STATIC); + if (isDisplayStatic) { + Manipulator.setDataAttribute(this._menu, 'popper', 'static'); } - - this._popper = new Popper__default['default'](referenceElement, this._menu, this._getPopperConfig()); } // If this is a touch-enabled device we add extra // empty mouseover listeners to the body's immediate children; // only needed because of broken event delegation on iOS // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html - if ('ontouchstart' in document.documentElement && $__default['default'](parent).closest(SELECTOR_NAVBAR_NAV).length === 0) { - $__default['default'](document.body).children().on('mouseover', null, $__default['default'].noop); + if ('ontouchstart' in document.documentElement && !parent.closest(SELECTOR_NAVBAR_NAV)) { + [].concat(...document.body.children).forEach(elem => EventHandler.on(elem, 'mouseover', noop)); } this._element.focus(); this._element.setAttribute('aria-expanded', true); - $__default['default'](this._menu).toggleClass(CLASS_NAME_SHOW$2); - $__default['default'](parent).toggleClass(CLASS_NAME_SHOW$2).trigger($__default['default'].Event(EVENT_SHOWN$1, relatedTarget)); - }; + this._menu.classList.toggle(CLASS_NAME_SHOW$7); + + this._element.classList.toggle(CLASS_NAME_SHOW$7); - _proto.hide = function hide() { - if (this._element.disabled || $__default['default'](this._element).hasClass(CLASS_NAME_DISABLED) || !$__default['default'](this._menu).hasClass(CLASS_NAME_SHOW$2)) { + EventHandler.trigger(this._element, EVENT_SHOWN$4, relatedTarget); + } + + hide() { + if (isDisabled(this._element) || !this._menu.classList.contains(CLASS_NAME_SHOW$7)) { return; } - var relatedTarget = { + const relatedTarget = { relatedTarget: this._element }; - var hideEvent = $__default['default'].Event(EVENT_HIDE$1, relatedTarget); - - var parent = Dropdown._getParentFromElement(this._element); - $__default['default'](parent).trigger(hideEvent); + this._completeHide(relatedTarget); + } - if (hideEvent.isDefaultPrevented()) { - return; + dispose() { + if (this._popper) { + this._popper.destroy(); } + super.dispose(); + } + + update() { + this._inNavbar = this._detectNavbar(); + if (this._popper) { - this._popper.destroy(); + this._popper.update(); } + } // Private - $__default['default'](this._menu).toggleClass(CLASS_NAME_SHOW$2); - $__default['default'](parent).toggleClass(CLASS_NAME_SHOW$2).trigger($__default['default'].Event(EVENT_HIDDEN$1, relatedTarget)); - }; - _proto.dispose = function dispose() { - $__default['default'].removeData(this._element, DATA_KEY$4); - $__default['default'](this._element).off(EVENT_KEY$4); - this._element = null; - this._menu = null; + _addEventListeners() { + EventHandler.on(this._element, EVENT_CLICK, event => { + event.preventDefault(); + this.toggle(); + }); + } - if (this._popper !== null) { - this._popper.destroy(); + _completeHide(relatedTarget) { + const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4, relatedTarget); - this._popper = null; - } - }; + if (hideEvent.defaultPrevented) { + return; + } // If this is a touch-enabled device we remove the extra + // empty mouseover listeners we added for iOS support - _proto.update = function update() { - this._inNavbar = this._detectNavbar(); - if (this._popper !== null) { - this._popper.scheduleUpdate(); + if ('ontouchstart' in document.documentElement) { + [].concat(...document.body.children).forEach(elem => EventHandler.off(elem, 'mouseover', noop)); + } + + if (this._popper) { + this._popper.destroy(); } - } // Private - ; - _proto._addEventListeners = function _addEventListeners() { - var _this = this; + this._menu.classList.remove(CLASS_NAME_SHOW$7); - $__default['default'](this._element).on(EVENT_CLICK, function (event) { - event.preventDefault(); - event.stopPropagation(); + this._element.classList.remove(CLASS_NAME_SHOW$7); - _this.toggle(); - }); - }; + this._element.setAttribute('aria-expanded', 'false'); + + Manipulator.removeDataAttribute(this._menu, 'popper'); + EventHandler.trigger(this._element, EVENT_HIDDEN$4, relatedTarget); + } + + _getConfig(config) { + config = { ...this.constructor.Default, + ...Manipulator.getDataAttributes(this._element), + ...config + }; + typeCheckConfig(NAME$8, config, this.constructor.DefaultType); + + if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') { + // Popper virtual elements require a getBoundingClientRect method + throw new TypeError(`${NAME$8.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`); + } - _proto._getConfig = function _getConfig(config) { - config = _extends({}, this.constructor.Default, $__default['default'](this._element).data(), config); - Util.typeCheckConfig(NAME$4, config, this.constructor.DefaultType); return config; - }; + } + + _getMenuElement() { + return SelectorEngine.next(this._element, SELECTOR_MENU)[0]; + } - _proto._getMenuElement = function _getMenuElement() { - if (!this._menu) { - var parent = Dropdown._getParentFromElement(this._element); + _getPlacement() { + const parentDropdown = this._element.parentNode; - if (parent) { - this._menu = parent.querySelector(SELECTOR_MENU); - } + if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) { + return PLACEMENT_RIGHT; } - return this._menu; - }; + if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) { + return PLACEMENT_LEFT; + } // We need to trim the value because custom properties can also include spaces + - _proto._getPlacement = function _getPlacement() { - var $parentDropdown = $__default['default'](this._element.parentNode); - var placement = PLACEMENT_BOTTOM; // Handle dropup + const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end'; - if ($parentDropdown.hasClass(CLASS_NAME_DROPUP)) { - placement = $__default['default'](this._menu).hasClass(CLASS_NAME_MENURIGHT) ? PLACEMENT_TOPEND : PLACEMENT_TOP; - } else if ($parentDropdown.hasClass(CLASS_NAME_DROPRIGHT)) { - placement = PLACEMENT_RIGHT; - } else if ($parentDropdown.hasClass(CLASS_NAME_DROPLEFT)) { - placement = PLACEMENT_LEFT; - } else if ($__default['default'](this._menu).hasClass(CLASS_NAME_MENURIGHT)) { - placement = PLACEMENT_BOTTOMEND; + if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) { + return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP; } - return placement; - }; + return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM; + } - _proto._detectNavbar = function _detectNavbar() { - return $__default['default'](this._element).closest('.navbar').length > 0; - }; + _detectNavbar() { + return this._element.closest(`.${CLASS_NAME_NAVBAR}`) !== null; + } - _proto._getOffset = function _getOffset() { - var _this2 = this; + _getOffset() { + const { + offset + } = this._config; - var offset = {}; + if (typeof offset === 'string') { + return offset.split(',').map(val => Number.parseInt(val, 10)); + } - if (typeof this._config.offset === 'function') { - offset.fn = function (data) { - data.offsets = _extends({}, data.offsets, _this2._config.offset(data.offsets, _this2._element) || {}); - return data; - }; - } else { - offset.offset = this._config.offset; + if (typeof offset === 'function') { + return popperData => offset(popperData, this._element); } return offset; - }; + } - _proto._getPopperConfig = function _getPopperConfig() { - var popperConfig = { + _getPopperConfig() { + const defaultBsPopperConfig = { placement: this._getPlacement(), - modifiers: { - offset: this._getOffset(), - flip: { - enabled: this._config.flip - }, - preventOverflow: { - boundariesElement: this._config.boundary + modifiers: [{ + name: 'preventOverflow', + options: { + boundary: this._config.boundary } - } + }, { + name: 'offset', + options: { + offset: this._getOffset() + } + }] }; // Disable Popper if we have a static display if (this._config.display === 'static') { - popperConfig.modifiers.applyStyle = { + defaultBsPopperConfig.modifiers = [{ + name: 'applyStyles', enabled: false - }; + }]; } - return _extends({}, popperConfig, this._config.popperConfig); - } // Static - ; + return { ...defaultBsPopperConfig, + ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig) + }; + } - Dropdown._jQueryInterface = function _jQueryInterface(config) { - return this.each(function () { - var data = $__default['default'](this).data(DATA_KEY$4); + _selectMenuItem(event) { + const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(isVisible); - var _config = typeof config === 'object' ? config : null; + if (!items.length) { + return; + } - if (!data) { - data = new Dropdown(this, _config); - $__default['default'](this).data(DATA_KEY$4, data); - } + let index = items.indexOf(event.target); // Up - if (typeof config === 'string') { - if (typeof data[config] === 'undefined') { - throw new TypeError("No method named \"" + config + "\""); - } + if (event.key === ARROW_UP_KEY && index > 0) { + index--; + } // Down - data[config](); - } - }); - }; - Dropdown._clearMenus = function _clearMenus(event) { - if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) { - return; - } + if (event.key === ARROW_DOWN_KEY && index < items.length - 1) { + index++; + } // index is -1 if the first keydown is an ArrowUp - var toggles = [].slice.call(document.querySelectorAll(SELECTOR_DATA_TOGGLE$2)); - for (var i = 0, len = toggles.length; i < len; i++) { - var parent = Dropdown._getParentFromElement(toggles[i]); + index = index === -1 ? 0 : index; + items[index].focus(); + } // Static - var context = $__default['default'](toggles[i]).data(DATA_KEY$4); - var relatedTarget = { - relatedTarget: toggles[i] - }; - if (event && event.type === 'click') { - relatedTarget.clickEvent = event; - } + static dropdownInterface(element, config) { + let data = Data.get(element, DATA_KEY$7); - if (!context) { - continue; + const _config = typeof config === 'object' ? config : null; + + if (!data) { + data = new Dropdown(element, _config); + } + + if (typeof config === 'string') { + if (typeof data[config] === 'undefined') { + throw new TypeError(`No method named "${config}"`); } - var dropdownMenu = context._menu; + data[config](); + } + } + + static jQueryInterface(config) { + return this.each(function () { + Dropdown.dropdownInterface(this, config); + }); + } + + static clearMenus(event) { + if (event && (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY)) { + return; + } - if (!$__default['default'](parent).hasClass(CLASS_NAME_SHOW$2)) { + const toggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE$3); + + for (let i = 0, len = toggles.length; i < len; i++) { + const context = Data.get(toggles[i], DATA_KEY$7); + + if (!context || context._config.autoClose === false) { continue; } - if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $__default['default'].contains(parent, event.target)) { + if (!context._element.classList.contains(CLASS_NAME_SHOW$7)) { continue; } - var hideEvent = $__default['default'].Event(EVENT_HIDE$1, relatedTarget); - $__default['default'](parent).trigger(hideEvent); + const relatedTarget = { + relatedTarget: context._element + }; - if (hideEvent.isDefaultPrevented()) { - continue; - } // If this is a touch-enabled device we remove the extra - // empty mouseover listeners we added for iOS support + if (event) { + const composedPath = event.composedPath(); + const isMenuTarget = composedPath.includes(context._menu); + if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) { + continue; + } // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu - if ('ontouchstart' in document.documentElement) { - $__default['default'](document.body).children().off('mouseover', null, $__default['default'].noop); - } - toggles[i].setAttribute('aria-expanded', 'false'); + if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY || /input|select|option|textarea|form/i.test(event.target.tagName))) { + continue; + } - if (context._popper) { - context._popper.destroy(); + if (event.type === 'click') { + relatedTarget.clickEvent = event; + } } - $__default['default'](dropdownMenu).removeClass(CLASS_NAME_SHOW$2); - $__default['default'](parent).removeClass(CLASS_NAME_SHOW$2).trigger($__default['default'].Event(EVENT_HIDDEN$1, relatedTarget)); - } - }; - - Dropdown._getParentFromElement = function _getParentFromElement(element) { - var parent; - var selector = Util.getSelectorFromElement(element); - - if (selector) { - parent = document.querySelector(selector); + context._completeHide(relatedTarget); } + } - return parent || element.parentNode; - } // eslint-disable-next-line complexity - ; + static getParentFromElement(element) { + return getElementFromSelector(element) || element.parentNode; + } - Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) { + static dataApiKeydownHandler(event) { // If not input/textarea: // - And not a key in REGEXP_KEYDOWN => not a dropdown command // If input/textarea: @@ -1942,80 +2381,45 @@ // - If key is other than escape // - If key is not up or down => not a dropdown command // - If trigger inside the menu => not a dropdown command - if (/input|textarea/i.test(event.target.tagName) ? event.which === SPACE_KEYCODE || event.which !== ESCAPE_KEYCODE && (event.which !== ARROW_DOWN_KEYCODE && event.which !== ARROW_UP_KEYCODE || $__default['default'](event.target).closest(SELECTOR_MENU).length) : !REGEXP_KEYDOWN.test(event.which)) { - return; - } - - if (this.disabled || $__default['default'](this).hasClass(CLASS_NAME_DISABLED)) { + if (/input|textarea/i.test(event.target.tagName) ? event.key === SPACE_KEY || event.key !== ESCAPE_KEY$2 && (event.key !== ARROW_DOWN_KEY && event.key !== ARROW_UP_KEY || event.target.closest(SELECTOR_MENU)) : !REGEXP_KEYDOWN.test(event.key)) { return; } - var parent = Dropdown._getParentFromElement(this); - - var isActive = $__default['default'](parent).hasClass(CLASS_NAME_SHOW$2); + const isActive = this.classList.contains(CLASS_NAME_SHOW$7); - if (!isActive && event.which === ESCAPE_KEYCODE) { + if (!isActive && event.key === ESCAPE_KEY$2) { return; } event.preventDefault(); event.stopPropagation(); - if (!isActive || event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE) { - if (event.which === ESCAPE_KEYCODE) { - $__default['default'](parent.querySelector(SELECTOR_DATA_TOGGLE$2)).trigger('focus'); - } - - $__default['default'](this).trigger('click'); + if (isDisabled(this)) { return; } - var items = [].slice.call(parent.querySelectorAll(SELECTOR_VISIBLE_ITEMS)).filter(function (item) { - return $__default['default'](item).is(':visible'); - }); + const getToggleButton = () => this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0]; - if (items.length === 0) { + if (event.key === ESCAPE_KEY$2) { + getToggleButton().focus(); + Dropdown.clearMenus(); return; } - var index = items.indexOf(event.target); - - if (event.which === ARROW_UP_KEYCODE && index > 0) { - // Up - index--; - } - - if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) { - // Down - index++; + if (!isActive && (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY)) { + getToggleButton().click(); + return; } - if (index < 0) { - index = 0; + if (!isActive || event.key === SPACE_KEY) { + Dropdown.clearMenus(); + return; } - items[index].focus(); - }; - - _createClass(Dropdown, null, [{ - key: "VERSION", - get: function get() { - return VERSION$4; - } - }, { - key: "Default", - get: function get() { - return Default$2; - } - }, { - key: "DefaultType", - get: function get() { - return DefaultType$2; - } - }]); + Dropdown.getInstance(getToggleButton())._selectMenuItem(event); + } - return Dropdown; - }(); + } /** * ------------------------------------------------------------------------ * Data Api implementation @@ -2023,131 +2427,324 @@ */ - $__default['default'](document).on(EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$2, Dropdown._dataApiKeydownHandler).on(EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown._dataApiKeydownHandler).on(EVENT_CLICK_DATA_API$4 + " " + EVENT_KEYUP_DATA_API, Dropdown._clearMenus).on(EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$2, function (event) { + EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler); + EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler); + EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus); + EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus); + EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) { event.preventDefault(); - event.stopPropagation(); - - Dropdown._jQueryInterface.call($__default['default'](this), 'toggle'); - }).on(EVENT_CLICK_DATA_API$4, SELECTOR_FORM_CHILD, function (e) { - e.stopPropagation(); + Dropdown.dropdownInterface(this); }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ + * add .Dropdown to jQuery only if jQuery is present */ - $__default['default'].fn[NAME$4] = Dropdown._jQueryInterface; - $__default['default'].fn[NAME$4].Constructor = Dropdown; + defineJQueryPlugin(Dropdown); + + /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): util/scrollBar.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'; + const SELECTOR_STICKY_CONTENT = '.sticky-top'; + + const getWidth = () => { + // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes + const documentWidth = document.documentElement.clientWidth; + return Math.abs(window.innerWidth - documentWidth); + }; + + const hide = (width = getWidth()) => { + _disableOverFlow(); // give padding to element to balances the hidden scrollbar width + + + _setElementAttributes('body', 'paddingRight', calculatedValue => calculatedValue + width); // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements, to keep shown fullwidth + + + _setElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight', calculatedValue => calculatedValue + width); + + _setElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight', calculatedValue => calculatedValue - width); + }; + + const _disableOverFlow = () => { + const actualValue = document.body.style.overflow; + + if (actualValue) { + Manipulator.setDataAttribute(document.body, 'overflow', actualValue); + } + + document.body.style.overflow = 'hidden'; + }; + + const _setElementAttributes = (selector, styleProp, callback) => { + const scrollbarWidth = getWidth(); + SelectorEngine.find(selector).forEach(element => { + if (element !== document.body && window.innerWidth > element.clientWidth + scrollbarWidth) { + return; + } + + const actualValue = element.style[styleProp]; + const calculatedValue = window.getComputedStyle(element)[styleProp]; + Manipulator.setDataAttribute(element, styleProp, actualValue); + element.style[styleProp] = `${callback(Number.parseFloat(calculatedValue))}px`; + }); + }; + + const reset = () => { + _resetElementAttributes('body', 'overflow'); + + _resetElementAttributes('body', 'paddingRight'); + + _resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight'); + + _resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight'); + }; + + const _resetElementAttributes = (selector, styleProp) => { + SelectorEngine.find(selector).forEach(element => { + const value = Manipulator.getDataAttribute(element, styleProp); + + if (typeof value === 'undefined') { + element.style.removeProperty(styleProp); + } else { + Manipulator.removeDataAttribute(element, styleProp); + element.style[styleProp] = value; + } + }); + }; - $__default['default'].fn[NAME$4].noConflict = function () { - $__default['default'].fn[NAME$4] = JQUERY_NO_CONFLICT$4; - return Dropdown._jQueryInterface; + /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): util/backdrop.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) + * -------------------------------------------------------------------------- + */ + const Default$6 = { + isVisible: true, + // if false, we use the backdrop helper without adding any element to the dom + isAnimated: false, + rootElement: document.body, + // give the choice to place backdrop under different elements + clickCallback: null + }; + const DefaultType$6 = { + isVisible: 'boolean', + isAnimated: 'boolean', + rootElement: 'element', + clickCallback: '(function|null)' }; + const NAME$7 = 'backdrop'; + const CLASS_NAME_BACKDROP = 'modal-backdrop'; + const CLASS_NAME_FADE$5 = 'fade'; + const CLASS_NAME_SHOW$6 = 'show'; + const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$7}`; + + class Backdrop { + constructor(config) { + this._config = this._getConfig(config); + this._isAppended = false; + this._element = null; + } + + show(callback) { + if (!this._config.isVisible) { + execute(callback); + return; + } + + this._append(); + + if (this._config.isAnimated) { + reflow(this._getElement()); + } + + this._getElement().classList.add(CLASS_NAME_SHOW$6); + + this._emulateAnimation(() => { + execute(callback); + }); + } + + hide(callback) { + if (!this._config.isVisible) { + execute(callback); + return; + } + + this._getElement().classList.remove(CLASS_NAME_SHOW$6); + + this._emulateAnimation(() => { + this.dispose(); + execute(callback); + }); + } // Private + + + _getElement() { + if (!this._element) { + const backdrop = document.createElement('div'); + backdrop.className = CLASS_NAME_BACKDROP; + + if (this._config.isAnimated) { + backdrop.classList.add(CLASS_NAME_FADE$5); + } + + this._element = backdrop; + } + + return this._element; + } + + _getConfig(config) { + config = { ...Default$6, + ...(typeof config === 'object' ? config : {}) + }; + config.rootElement = config.rootElement || document.body; + typeCheckConfig(NAME$7, config, DefaultType$6); + return config; + } + + _append() { + if (this._isAppended) { + return; + } + + this._config.rootElement.appendChild(this._getElement()); + + EventHandler.on(this._getElement(), EVENT_MOUSEDOWN, () => { + execute(this._config.clickCallback); + }); + this._isAppended = true; + } + + dispose() { + if (!this._isAppended) { + return; + } + + EventHandler.off(this._element, EVENT_MOUSEDOWN); + + this._getElement().parentNode.removeChild(this._element); + this._isAppended = false; + } + + _emulateAnimation(callback) { + if (!this._config.isAnimated) { + execute(callback); + return; + } + + const backdropTransitionDuration = getTransitionDurationFromElement(this._getElement()); + EventHandler.one(this._getElement(), 'transitionend', () => execute(callback)); + emulateTransitionEnd(this._getElement(), backdropTransitionDuration); + } + + } + + /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): modal.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ - var NAME$5 = 'modal'; - var VERSION$5 = '4.6.0'; - var DATA_KEY$5 = 'bs.modal'; - var EVENT_KEY$5 = "." + DATA_KEY$5; - var DATA_API_KEY$5 = '.data-api'; - var JQUERY_NO_CONFLICT$5 = $__default['default'].fn[NAME$5]; - var ESCAPE_KEYCODE$1 = 27; // KeyboardEvent.which value for Escape (Esc) key - - var Default$3 = { + const NAME$6 = 'modal'; + const DATA_KEY$6 = 'bs.modal'; + const EVENT_KEY$6 = `.${DATA_KEY$6}`; + const DATA_API_KEY$3 = '.data-api'; + const ESCAPE_KEY$1 = 'Escape'; + const Default$5 = { backdrop: true, keyboard: true, - focus: true, - show: true + focus: true }; - var DefaultType$3 = { + const DefaultType$5 = { backdrop: '(boolean|string)', keyboard: 'boolean', - focus: 'boolean', - show: 'boolean' + focus: 'boolean' }; - var EVENT_HIDE$2 = "hide" + EVENT_KEY$5; - var EVENT_HIDE_PREVENTED = "hidePrevented" + EVENT_KEY$5; - var EVENT_HIDDEN$2 = "hidden" + EVENT_KEY$5; - var EVENT_SHOW$2 = "show" + EVENT_KEY$5; - var EVENT_SHOWN$2 = "shown" + EVENT_KEY$5; - var EVENT_FOCUSIN = "focusin" + EVENT_KEY$5; - var EVENT_RESIZE = "resize" + EVENT_KEY$5; - var EVENT_CLICK_DISMISS = "click.dismiss" + EVENT_KEY$5; - var EVENT_KEYDOWN_DISMISS = "keydown.dismiss" + EVENT_KEY$5; - var EVENT_MOUSEUP_DISMISS = "mouseup.dismiss" + EVENT_KEY$5; - var EVENT_MOUSEDOWN_DISMISS = "mousedown.dismiss" + EVENT_KEY$5; - var EVENT_CLICK_DATA_API$5 = "click" + EVENT_KEY$5 + DATA_API_KEY$5; - var CLASS_NAME_SCROLLABLE = 'modal-dialog-scrollable'; - var CLASS_NAME_SCROLLBAR_MEASURER = 'modal-scrollbar-measure'; - var CLASS_NAME_BACKDROP = 'modal-backdrop'; - var CLASS_NAME_OPEN = 'modal-open'; - var CLASS_NAME_FADE$1 = 'fade'; - var CLASS_NAME_SHOW$3 = 'show'; - var CLASS_NAME_STATIC = 'modal-static'; - var SELECTOR_DIALOG = '.modal-dialog'; - var SELECTOR_MODAL_BODY = '.modal-body'; - var SELECTOR_DATA_TOGGLE$3 = '[data-toggle="modal"]'; - var SELECTOR_DATA_DISMISS = '[data-dismiss="modal"]'; - var SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'; - var SELECTOR_STICKY_CONTENT = '.sticky-top'; + const EVENT_HIDE$3 = `hide${EVENT_KEY$6}`; + const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$6}`; + const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$6}`; + const EVENT_SHOW$3 = `show${EVENT_KEY$6}`; + const EVENT_SHOWN$3 = `shown${EVENT_KEY$6}`; + const EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$6}`; + const EVENT_RESIZE = `resize${EVENT_KEY$6}`; + const EVENT_CLICK_DISMISS$2 = `click.dismiss${EVENT_KEY$6}`; + const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$6}`; + const EVENT_MOUSEUP_DISMISS = `mouseup.dismiss${EVENT_KEY$6}`; + const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$6}`; + const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`; + const CLASS_NAME_OPEN = 'modal-open'; + const CLASS_NAME_FADE$4 = 'fade'; + const CLASS_NAME_SHOW$5 = 'show'; + const CLASS_NAME_STATIC = 'modal-static'; + const SELECTOR_DIALOG = '.modal-dialog'; + const SELECTOR_MODAL_BODY = '.modal-body'; + const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]'; + const SELECTOR_DATA_DISMISS$2 = '[data-bs-dismiss="modal"]'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ - var Modal = /*#__PURE__*/function () { - function Modal(element, config) { + class Modal extends BaseComponent { + constructor(element, config) { + super(element); this._config = this._getConfig(config); - this._element = element; - this._dialog = element.querySelector(SELECTOR_DIALOG); - this._backdrop = null; + this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element); + this._backdrop = this._initializeBackDrop(); this._isShown = false; - this._isBodyOverflowing = false; this._ignoreBackdropClick = false; this._isTransitioning = false; - this._scrollbarWidth = 0; } // Getters - var _proto = Modal.prototype; + static get Default() { + return Default$5; + } - // Public - _proto.toggle = function toggle(relatedTarget) { - return this._isShown ? this.hide() : this.show(relatedTarget); - }; + static get NAME() { + return NAME$6; + } // Public - _proto.show = function show(relatedTarget) { - var _this = this; + toggle(relatedTarget) { + return this._isShown ? this.hide() : this.show(relatedTarget); + } + + show(relatedTarget) { if (this._isShown || this._isTransitioning) { return; } - if ($__default['default'](this._element).hasClass(CLASS_NAME_FADE$1)) { + if (this._isAnimated()) { this._isTransitioning = true; } - var showEvent = $__default['default'].Event(EVENT_SHOW$2, { - relatedTarget: relatedTarget + const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, { + relatedTarget }); - $__default['default'](this._element).trigger(showEvent); - if (this._isShown || showEvent.isDefaultPrevented()) { + if (this._isShown || showEvent.defaultPrevented) { return; } this._isShown = true; - - this._checkScrollbar(); - - this._setScrollbar(); + hide(); + document.body.classList.add(CLASS_NAME_OPEN); this._adjustDialog(); @@ -2155,25 +2752,19 @@ this._setResizeEvent(); - $__default['default'](this._element).on(EVENT_CLICK_DISMISS, SELECTOR_DATA_DISMISS, function (event) { - return _this.hide(event); - }); - $__default['default'](this._dialog).on(EVENT_MOUSEDOWN_DISMISS, function () { - $__default['default'](_this._element).one(EVENT_MOUSEUP_DISMISS, function (event) { - if ($__default['default'](event.target).is(_this._element)) { - _this._ignoreBackdropClick = true; + EventHandler.on(this._element, EVENT_CLICK_DISMISS$2, SELECTOR_DATA_DISMISS$2, event => this.hide(event)); + EventHandler.on(this._dialog, EVENT_MOUSEDOWN_DISMISS, () => { + EventHandler.one(this._element, EVENT_MOUSEUP_DISMISS, event => { + if (event.target === this._element) { + this._ignoreBackdropClick = true; } }); }); - this._showBackdrop(function () { - return _this._showElement(relatedTarget); - }); - }; - - _proto.hide = function hide(event) { - var _this2 = this; + this._showBackdrop(() => this._showElement(relatedTarget)); + } + hide(event) { if (event) { event.preventDefault(); } @@ -2182,17 +2773,17 @@ return; } - var hideEvent = $__default['default'].Event(EVENT_HIDE$2); - $__default['default'](this._element).trigger(hideEvent); + const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3); - if (!this._isShown || hideEvent.isDefaultPrevented()) { + if (hideEvent.defaultPrevented) { return; } this._isShown = false; - var transition = $__default['default'](this._element).hasClass(CLASS_NAME_FADE$1); - if (transition) { + const isAnimated = this._isAnimated(); + + if (isAnimated) { this._isTransitioning = true; } @@ -2200,93 +2791,57 @@ this._setResizeEvent(); - $__default['default'](document).off(EVENT_FOCUSIN); - $__default['default'](this._element).removeClass(CLASS_NAME_SHOW$3); - $__default['default'](this._element).off(EVENT_CLICK_DISMISS); - $__default['default'](this._dialog).off(EVENT_MOUSEDOWN_DISMISS); + EventHandler.off(document, EVENT_FOCUSIN$2); - if (transition) { - var transitionDuration = Util.getTransitionDurationFromElement(this._element); - $__default['default'](this._element).one(Util.TRANSITION_END, function (event) { - return _this2._hideModal(event); - }).emulateTransitionEnd(transitionDuration); - } else { - this._hideModal(); - } - }; + this._element.classList.remove(CLASS_NAME_SHOW$5); - _proto.dispose = function dispose() { - [window, this._element, this._dialog].forEach(function (htmlElement) { - return $__default['default'](htmlElement).off(EVENT_KEY$5); - }); + EventHandler.off(this._element, EVENT_CLICK_DISMISS$2); + EventHandler.off(this._dialog, EVENT_MOUSEDOWN_DISMISS); + + this._queueCallback(() => this._hideModal(), this._element, isAnimated); + } + + dispose() { + [window, this._dialog].forEach(htmlElement => EventHandler.off(htmlElement, EVENT_KEY$6)); + + this._backdrop.dispose(); + + super.dispose(); /** * `document` has 2 events `EVENT_FOCUSIN` and `EVENT_CLICK_DATA_API` * Do not move `document` in `htmlElements` array * It will remove `EVENT_CLICK_DATA_API` event that should remain */ - $__default['default'](document).off(EVENT_FOCUSIN); - $__default['default'].removeData(this._element, DATA_KEY$5); - this._config = null; - this._element = null; - this._dialog = null; - this._backdrop = null; - this._isShown = null; - this._isBodyOverflowing = null; - this._ignoreBackdropClick = null; - this._isTransitioning = null; - this._scrollbarWidth = null; - }; + EventHandler.off(document, EVENT_FOCUSIN$2); + } - _proto.handleUpdate = function handleUpdate() { + handleUpdate() { this._adjustDialog(); } // Private - ; - - _proto._getConfig = function _getConfig(config) { - config = _extends({}, Default$3, config); - Util.typeCheckConfig(NAME$5, config, DefaultType$3); - return config; - }; - - _proto._triggerBackdropTransition = function _triggerBackdropTransition() { - var _this3 = this; - - var hideEventPrevented = $__default['default'].Event(EVENT_HIDE_PREVENTED); - $__default['default'](this._element).trigger(hideEventPrevented); - - if (hideEventPrevented.isDefaultPrevented()) { - return; - } - - var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; - if (!isModalOverflowing) { - this._element.style.overflowY = 'hidden'; - } - this._element.classList.add(CLASS_NAME_STATIC); - - var modalTransitionDuration = Util.getTransitionDurationFromElement(this._dialog); - $__default['default'](this._element).off(Util.TRANSITION_END); - $__default['default'](this._element).one(Util.TRANSITION_END, function () { - _this3._element.classList.remove(CLASS_NAME_STATIC); - - if (!isModalOverflowing) { - $__default['default'](_this3._element).one(Util.TRANSITION_END, function () { - _this3._element.style.overflowY = ''; - }).emulateTransitionEnd(_this3._element, modalTransitionDuration); - } - }).emulateTransitionEnd(modalTransitionDuration); + _initializeBackDrop() { + return new Backdrop({ + isVisible: Boolean(this._config.backdrop), + // 'static' option will be translated to true, and booleans will keep their value + isAnimated: this._isAnimated() + }); + } - this._element.focus(); - }; + _getConfig(config) { + config = { ...Default$5, + ...Manipulator.getDataAttributes(this._element), + ...config + }; + typeCheckConfig(NAME$6, config, DefaultType$5); + return config; + } - _proto._showElement = function _showElement(relatedTarget) { - var _this4 = this; + _showElement(relatedTarget) { + const isAnimated = this._isAnimated(); - var transition = $__default['default'](this._element).hasClass(CLASS_NAME_FADE$1); - var modalBody = this._dialog ? this._dialog.querySelector(SELECTOR_MODAL_BODY) : null; + const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog); if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) { // Don't move modal's DOM position @@ -2301,87 +2856,70 @@ this._element.setAttribute('role', 'dialog'); - if ($__default['default'](this._dialog).hasClass(CLASS_NAME_SCROLLABLE) && modalBody) { + this._element.scrollTop = 0; + + if (modalBody) { modalBody.scrollTop = 0; - } else { - this._element.scrollTop = 0; } - if (transition) { - Util.reflow(this._element); + if (isAnimated) { + reflow(this._element); } - $__default['default'](this._element).addClass(CLASS_NAME_SHOW$3); + this._element.classList.add(CLASS_NAME_SHOW$5); if (this._config.focus) { this._enforceFocus(); } - var shownEvent = $__default['default'].Event(EVENT_SHOWN$2, { - relatedTarget: relatedTarget - }); - - var transitionComplete = function transitionComplete() { - if (_this4._config.focus) { - _this4._element.focus(); + const transitionComplete = () => { + if (this._config.focus) { + this._element.focus(); } - _this4._isTransitioning = false; - $__default['default'](_this4._element).trigger(shownEvent); + this._isTransitioning = false; + EventHandler.trigger(this._element, EVENT_SHOWN$3, { + relatedTarget + }); }; - if (transition) { - var transitionDuration = Util.getTransitionDurationFromElement(this._dialog); - $__default['default'](this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(transitionDuration); - } else { - transitionComplete(); - } - }; + this._queueCallback(transitionComplete, this._dialog, isAnimated); + } - _proto._enforceFocus = function _enforceFocus() { - var _this5 = this; + _enforceFocus() { + EventHandler.off(document, EVENT_FOCUSIN$2); // guard against infinite focus loop - $__default['default'](document).off(EVENT_FOCUSIN) // Guard against infinite focus loop - .on(EVENT_FOCUSIN, function (event) { - if (document !== event.target && _this5._element !== event.target && $__default['default'](_this5._element).has(event.target).length === 0) { - _this5._element.focus(); + EventHandler.on(document, EVENT_FOCUSIN$2, event => { + if (document !== event.target && this._element !== event.target && !this._element.contains(event.target)) { + this._element.focus(); } }); - }; - - _proto._setEscapeEvent = function _setEscapeEvent() { - var _this6 = this; + } + _setEscapeEvent() { if (this._isShown) { - $__default['default'](this._element).on(EVENT_KEYDOWN_DISMISS, function (event) { - if (_this6._config.keyboard && event.which === ESCAPE_KEYCODE$1) { + EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => { + if (this._config.keyboard && event.key === ESCAPE_KEY$1) { event.preventDefault(); - - _this6.hide(); - } else if (!_this6._config.keyboard && event.which === ESCAPE_KEYCODE$1) { - _this6._triggerBackdropTransition(); + this.hide(); + } else if (!this._config.keyboard && event.key === ESCAPE_KEY$1) { + this._triggerBackdropTransition(); } }); - } else if (!this._isShown) { - $__default['default'](this._element).off(EVENT_KEYDOWN_DISMISS); + } else { + EventHandler.off(this._element, EVENT_KEYDOWN_DISMISS$1); } - }; - - _proto._setResizeEvent = function _setResizeEvent() { - var _this7 = this; + } + _setResizeEvent() { if (this._isShown) { - $__default['default'](window).on(EVENT_RESIZE, function (event) { - return _this7.handleUpdate(event); - }); + EventHandler.on(window, EVENT_RESIZE, () => this._adjustDialog()); } else { - $__default['default'](window).off(EVENT_RESIZE); + EventHandler.off(window, EVENT_RESIZE); } - }; - - _proto._hideModal = function _hideModal() { - var _this8 = this; + } + _hideModal() { this._element.style.display = 'none'; this._element.setAttribute('aria-hidden', true); @@ -2392,222 +2930,366 @@ this._isTransitioning = false; - this._showBackdrop(function () { - $__default['default'](document.body).removeClass(CLASS_NAME_OPEN); + this._backdrop.hide(() => { + document.body.classList.remove(CLASS_NAME_OPEN); - _this8._resetAdjustments(); + this._resetAdjustments(); - _this8._resetScrollbar(); + reset(); + EventHandler.trigger(this._element, EVENT_HIDDEN$3); + }); + } - $__default['default'](_this8._element).trigger(EVENT_HIDDEN$2); + _showBackdrop(callback) { + EventHandler.on(this._element, EVENT_CLICK_DISMISS$2, event => { + if (this._ignoreBackdropClick) { + this._ignoreBackdropClick = false; + return; + } + + if (event.target !== event.currentTarget) { + return; + } + + if (this._config.backdrop === true) { + this.hide(); + } else if (this._config.backdrop === 'static') { + this._triggerBackdropTransition(); + } }); - }; - _proto._removeBackdrop = function _removeBackdrop() { - if (this._backdrop) { - $__default['default'](this._backdrop).remove(); - this._backdrop = null; + this._backdrop.show(callback); + } + + _isAnimated() { + return this._element.classList.contains(CLASS_NAME_FADE$4); + } + + _triggerBackdropTransition() { + const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED); + + if (hideEvent.defaultPrevented) { + return; } - }; - _proto._showBackdrop = function _showBackdrop(callback) { - var _this9 = this; + const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; - var animate = $__default['default'](this._element).hasClass(CLASS_NAME_FADE$1) ? CLASS_NAME_FADE$1 : ''; + if (!isModalOverflowing) { + this._element.style.overflowY = 'hidden'; + } + + this._element.classList.add(CLASS_NAME_STATIC); - if (this._isShown && this._config.backdrop) { - this._backdrop = document.createElement('div'); - this._backdrop.className = CLASS_NAME_BACKDROP; + const modalTransitionDuration = getTransitionDurationFromElement(this._dialog); + EventHandler.off(this._element, 'transitionend'); + EventHandler.one(this._element, 'transitionend', () => { + this._element.classList.remove(CLASS_NAME_STATIC); - if (animate) { - this._backdrop.classList.add(animate); + if (!isModalOverflowing) { + EventHandler.one(this._element, 'transitionend', () => { + this._element.style.overflowY = ''; + }); + emulateTransitionEnd(this._element, modalTransitionDuration); } + }); + emulateTransitionEnd(this._element, modalTransitionDuration); - $__default['default'](this._backdrop).appendTo(document.body); - $__default['default'](this._element).on(EVENT_CLICK_DISMISS, function (event) { - if (_this9._ignoreBackdropClick) { - _this9._ignoreBackdropClick = false; - return; - } + this._element.focus(); + } // ---------------------------------------------------------------------- + // the following methods are used to handle overflowing modals + // ---------------------------------------------------------------------- - if (event.target !== event.currentTarget) { - return; - } - if (_this9._config.backdrop === 'static') { - _this9._triggerBackdropTransition(); - } else { - _this9.hide(); - } - }); + _adjustDialog() { + const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; + const scrollbarWidth = getWidth(); + const isBodyOverflowing = scrollbarWidth > 0; - if (animate) { - Util.reflow(this._backdrop); - } + if (!isBodyOverflowing && isModalOverflowing && !isRTL() || isBodyOverflowing && !isModalOverflowing && isRTL()) { + this._element.style.paddingLeft = `${scrollbarWidth}px`; + } - $__default['default'](this._backdrop).addClass(CLASS_NAME_SHOW$3); + if (isBodyOverflowing && !isModalOverflowing && !isRTL() || !isBodyOverflowing && isModalOverflowing && isRTL()) { + this._element.style.paddingRight = `${scrollbarWidth}px`; + } + } + + _resetAdjustments() { + this._element.style.paddingLeft = ''; + this._element.style.paddingRight = ''; + } // Static - if (!callback) { + + static jQueryInterface(config, relatedTarget) { + return this.each(function () { + const data = Modal.getInstance(this) || new Modal(this, typeof config === 'object' ? config : {}); + + if (typeof config !== 'string') { return; } - if (!animate) { - callback(); - return; + if (typeof data[config] === 'undefined') { + throw new TypeError(`No method named "${config}"`); } - var backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop); - $__default['default'](this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(backdropTransitionDuration); - } else if (!this._isShown && this._backdrop) { - $__default['default'](this._backdrop).removeClass(CLASS_NAME_SHOW$3); + data[config](relatedTarget); + }); + } - var callbackRemove = function callbackRemove() { - _this9._removeBackdrop(); + } + /** + * ------------------------------------------------------------------------ + * Data Api implementation + * ------------------------------------------------------------------------ + */ - if (callback) { - callback(); - } - }; - if ($__default['default'](this._element).hasClass(CLASS_NAME_FADE$1)) { - var _backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop); + EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) { + const target = getElementFromSelector(this); - $__default['default'](this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(_backdropTransitionDuration); - } else { - callbackRemove(); + if (['A', 'AREA'].includes(this.tagName)) { + event.preventDefault(); + } + + EventHandler.one(target, EVENT_SHOW$3, showEvent => { + if (showEvent.defaultPrevented) { + // only register focus restorer if modal will actually get shown + return; + } + + EventHandler.one(target, EVENT_HIDDEN$3, () => { + if (isVisible(this)) { + this.focus(); } - } else if (callback) { - callback(); + }); + }); + const data = Modal.getInstance(target) || new Modal(target); + data.toggle(this); + }); + /** + * ------------------------------------------------------------------------ + * jQuery + * ------------------------------------------------------------------------ + * add .Modal to jQuery only if jQuery is present + */ + + defineJQueryPlugin(Modal); + + /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): offcanvas.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) + * -------------------------------------------------------------------------- + */ + /** + * ------------------------------------------------------------------------ + * Constants + * ------------------------------------------------------------------------ + */ + + const NAME$5 = 'offcanvas'; + const DATA_KEY$5 = 'bs.offcanvas'; + const EVENT_KEY$5 = `.${DATA_KEY$5}`; + const DATA_API_KEY$2 = '.data-api'; + const EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$5}${DATA_API_KEY$2}`; + const ESCAPE_KEY = 'Escape'; + const Default$4 = { + backdrop: true, + keyboard: true, + scroll: false + }; + const DefaultType$4 = { + backdrop: 'boolean', + keyboard: 'boolean', + scroll: 'boolean' + }; + const CLASS_NAME_SHOW$4 = 'show'; + const OPEN_SELECTOR = '.offcanvas.show'; + const EVENT_SHOW$2 = `show${EVENT_KEY$5}`; + const EVENT_SHOWN$2 = `shown${EVENT_KEY$5}`; + const EVENT_HIDE$2 = `hide${EVENT_KEY$5}`; + const EVENT_HIDDEN$2 = `hidden${EVENT_KEY$5}`; + const EVENT_FOCUSIN$1 = `focusin${EVENT_KEY$5}`; + const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$5}${DATA_API_KEY$2}`; + const EVENT_CLICK_DISMISS$1 = `click.dismiss${EVENT_KEY$5}`; + const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$5}`; + const SELECTOR_DATA_DISMISS$1 = '[data-bs-dismiss="offcanvas"]'; + const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]'; + /** + * ------------------------------------------------------------------------ + * Class Definition + * ------------------------------------------------------------------------ + */ + + class Offcanvas extends BaseComponent { + constructor(element, config) { + super(element); + this._config = this._getConfig(config); + this._isShown = false; + this._backdrop = this._initializeBackDrop(); + + this._addEventListeners(); + } // Getters + + + static get NAME() { + return NAME$5; + } + + static get Default() { + return Default$4; + } // Public + + + toggle(relatedTarget) { + return this._isShown ? this.hide() : this.show(relatedTarget); + } + + show(relatedTarget) { + if (this._isShown) { + return; } - } // ---------------------------------------------------------------------- - // the following methods are used to handle overflowing modals - // todo (fat): these should probably be refactored out of modal.js - // ---------------------------------------------------------------------- - ; - _proto._adjustDialog = function _adjustDialog() { - var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; + const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$2, { + relatedTarget + }); - if (!this._isBodyOverflowing && isModalOverflowing) { - this._element.style.paddingLeft = this._scrollbarWidth + "px"; + if (showEvent.defaultPrevented) { + return; } - if (this._isBodyOverflowing && !isModalOverflowing) { - this._element.style.paddingRight = this._scrollbarWidth + "px"; + this._isShown = true; + this._element.style.visibility = 'visible'; + + this._backdrop.show(); + + if (!this._config.scroll) { + hide(); + + this._enforceFocusOnElement(this._element); } - }; - _proto._resetAdjustments = function _resetAdjustments() { - this._element.style.paddingLeft = ''; - this._element.style.paddingRight = ''; - }; + this._element.removeAttribute('aria-hidden'); - _proto._checkScrollbar = function _checkScrollbar() { - var rect = document.body.getBoundingClientRect(); - this._isBodyOverflowing = Math.round(rect.left + rect.right) < window.innerWidth; - this._scrollbarWidth = this._getScrollbarWidth(); - }; + this._element.setAttribute('aria-modal', true); + + this._element.setAttribute('role', 'dialog'); + + this._element.classList.add(CLASS_NAME_SHOW$4); - _proto._setScrollbar = function _setScrollbar() { - var _this10 = this; + const completeCallBack = () => { + EventHandler.trigger(this._element, EVENT_SHOWN$2, { + relatedTarget + }); + }; - if (this._isBodyOverflowing) { - // Note: DOMNode.style.paddingRight returns the actual value or '' if not set - // while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set - var fixedContent = [].slice.call(document.querySelectorAll(SELECTOR_FIXED_CONTENT)); - var stickyContent = [].slice.call(document.querySelectorAll(SELECTOR_STICKY_CONTENT)); // Adjust fixed content padding + this._queueCallback(completeCallBack, this._element, true); + } - $__default['default'](fixedContent).each(function (index, element) { - var actualPadding = element.style.paddingRight; - var calculatedPadding = $__default['default'](element).css('padding-right'); - $__default['default'](element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this10._scrollbarWidth + "px"); - }); // Adjust sticky content margin + hide() { + if (!this._isShown) { + return; + } - $__default['default'](stickyContent).each(function (index, element) { - var actualMargin = element.style.marginRight; - var calculatedMargin = $__default['default'](element).css('margin-right'); - $__default['default'](element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this10._scrollbarWidth + "px"); - }); // Adjust body padding + const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$2); - var actualPadding = document.body.style.paddingRight; - var calculatedPadding = $__default['default'](document.body).css('padding-right'); - $__default['default'](document.body).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px"); + if (hideEvent.defaultPrevented) { + return; } - $__default['default'](document.body).addClass(CLASS_NAME_OPEN); - }; + EventHandler.off(document, EVENT_FOCUSIN$1); - _proto._resetScrollbar = function _resetScrollbar() { - // Restore fixed content padding - var fixedContent = [].slice.call(document.querySelectorAll(SELECTOR_FIXED_CONTENT)); - $__default['default'](fixedContent).each(function (index, element) { - var padding = $__default['default'](element).data('padding-right'); - $__default['default'](element).removeData('padding-right'); - element.style.paddingRight = padding ? padding : ''; - }); // Restore sticky content - - var elements = [].slice.call(document.querySelectorAll("" + SELECTOR_STICKY_CONTENT)); - $__default['default'](elements).each(function (index, element) { - var margin = $__default['default'](element).data('margin-right'); - - if (typeof margin !== 'undefined') { - $__default['default'](element).css('margin-right', margin).removeData('margin-right'); - } - }); // Restore body padding + this._element.blur(); - var padding = $__default['default'](document.body).data('padding-right'); - $__default['default'](document.body).removeData('padding-right'); - document.body.style.paddingRight = padding ? padding : ''; - }; + this._isShown = false; - _proto._getScrollbarWidth = function _getScrollbarWidth() { - // thx d.walsh - var scrollDiv = document.createElement('div'); - scrollDiv.className = CLASS_NAME_SCROLLBAR_MEASURER; - document.body.appendChild(scrollDiv); - var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth; - document.body.removeChild(scrollDiv); - return scrollbarWidth; - } // Static - ; + this._element.classList.remove(CLASS_NAME_SHOW$4); - Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) { - return this.each(function () { - var data = $__default['default'](this).data(DATA_KEY$5); + this._backdrop.hide(); - var _config = _extends({}, Default$3, $__default['default'](this).data(), typeof config === 'object' && config ? config : {}); + const completeCallback = () => { + this._element.setAttribute('aria-hidden', true); - if (!data) { - data = new Modal(this, _config); - $__default['default'](this).data(DATA_KEY$5, data); + this._element.removeAttribute('aria-modal'); + + this._element.removeAttribute('role'); + + this._element.style.visibility = 'hidden'; + + if (!this._config.scroll) { + reset(); } - if (typeof config === 'string') { - if (typeof data[config] === 'undefined') { - throw new TypeError("No method named \"" + config + "\""); - } + EventHandler.trigger(this._element, EVENT_HIDDEN$2); + }; - data[config](relatedTarget); - } else if (_config.show) { - data.show(relatedTarget); + this._queueCallback(completeCallback, this._element, true); + } + + dispose() { + this._backdrop.dispose(); + + super.dispose(); + EventHandler.off(document, EVENT_FOCUSIN$1); + } // Private + + + _getConfig(config) { + config = { ...Default$4, + ...Manipulator.getDataAttributes(this._element), + ...(typeof config === 'object' ? config : {}) + }; + typeCheckConfig(NAME$5, config, DefaultType$4); + return config; + } + + _initializeBackDrop() { + return new Backdrop({ + isVisible: this._config.backdrop, + isAnimated: true, + rootElement: this._element.parentNode, + clickCallback: () => this.hide() + }); + } + + _enforceFocusOnElement(element) { + EventHandler.off(document, EVENT_FOCUSIN$1); // guard against infinite focus loop + + EventHandler.on(document, EVENT_FOCUSIN$1, event => { + if (document !== event.target && element !== event.target && !element.contains(event.target)) { + element.focus(); } }); - }; + element.focus(); + } - _createClass(Modal, null, [{ - key: "VERSION", - get: function get() { - return VERSION$5; - } - }, { - key: "Default", - get: function get() { - return Default$3; - } - }]); + _addEventListeners() { + EventHandler.on(this._element, EVENT_CLICK_DISMISS$1, SELECTOR_DATA_DISMISS$1, () => this.hide()); + EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => { + if (this._config.keyboard && event.key === ESCAPE_KEY) { + this.hide(); + } + }); + } // Static + + + static jQueryInterface(config) { + return this.each(function () { + const data = Data.get(this, DATA_KEY$5) || new Offcanvas(this, typeof config === 'object' ? config : {}); + + if (typeof config !== 'string') { + return; + } + + if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { + throw new TypeError(`No method named "${config}"`); + } + + data[config](this); + }); + } - return Modal; - }(); + } /** * ------------------------------------------------------------------------ * Data Api implementation @@ -2615,36 +3297,35 @@ */ - $__default['default'](document).on(EVENT_CLICK_DATA_API$5, SELECTOR_DATA_TOGGLE$3, function (event) { - var _this11 = this; - - var target; - var selector = Util.getSelectorFromElement(this); + EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) { + const target = getElementFromSelector(this); - if (selector) { - target = document.querySelector(selector); + if (['A', 'AREA'].includes(this.tagName)) { + event.preventDefault(); } - var config = $__default['default'](target).data(DATA_KEY$5) ? 'toggle' : _extends({}, $__default['default'](target).data(), $__default['default'](this).data()); - - if (this.tagName === 'A' || this.tagName === 'AREA') { - event.preventDefault(); + if (isDisabled(this)) { + return; } - var $target = $__default['default'](target).one(EVENT_SHOW$2, function (showEvent) { - if (showEvent.isDefaultPrevented()) { - // Only register focus restorer if modal will actually get shown - return; + EventHandler.one(target, EVENT_HIDDEN$2, () => { + // focus on trigger when it is closed + if (isVisible(this)) { + this.focus(); } + }); // avoid conflict when clicking a toggler of an offcanvas, while another is open - $target.one(EVENT_HIDDEN$2, function () { - if ($__default['default'](_this11).is(':visible')) { - _this11.focus(); - } - }); - }); + const allReadyOpen = SelectorEngine.findOne(OPEN_SELECTOR); - Modal._jQueryInterface.call($__default['default'](target), config, this); + if (allReadyOpen && allReadyOpen !== target) { + Offcanvas.getInstance(allReadyOpen).hide(); + } + + const data = Data.get(target, DATA_KEY$5) || new Offcanvas(target); + data.toggle(this); + }); + EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => { + SelectorEngine.find(OPEN_SELECTOR).forEach(el => (Data.get(el, DATA_KEY$5) || new Offcanvas(el)).show()); }); /** * ------------------------------------------------------------------------ @@ -2652,23 +3333,54 @@ * ------------------------------------------------------------------------ */ - $__default['default'].fn[NAME$5] = Modal._jQueryInterface; - $__default['default'].fn[NAME$5].Constructor = Modal; - - $__default['default'].fn[NAME$5].noConflict = function () { - $__default['default'].fn[NAME$5] = JQUERY_NO_CONFLICT$5; - return Modal._jQueryInterface; - }; + defineJQueryPlugin(Offcanvas); /** * -------------------------------------------------------------------------- - * Bootstrap (v4.6.0): tools/sanitizer.js + * Bootstrap (v5.0.1): util/sanitizer.js * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) * -------------------------------------------------------------------------- */ - var uriAttrs = ['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']; - var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i; - var DefaultWhitelist = { + const uriAttrs = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']); + const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i; + /** + * A pattern that recognizes a commonly useful subset of URLs that are safe. + * + * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts + */ + + const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^#&/:?]*(?:[#/?]|$))/i; + /** + * A pattern that matches safe data URLs. Only matches image, video and audio types. + * + * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts + */ + + const DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i; + + const allowedAttribute = (attr, allowedAttributeList) => { + const attrName = attr.nodeName.toLowerCase(); + + if (allowedAttributeList.includes(attrName)) { + if (uriAttrs.has(attrName)) { + return Boolean(SAFE_URL_PATTERN.test(attr.nodeValue) || DATA_URL_PATTERN.test(attr.nodeValue)); + } + + return true; + } + + const regExp = allowedAttributeList.filter(attrRegex => attrRegex instanceof RegExp); // Check if a regular expression validates the attribute. + + for (let i = 0, len = regExp.length; i < len; i++) { + if (regExp[i].test(attrName)) { + return true; + } + } + + return false; + }; + + const DefaultAllowlist = { // Global attributes allowed on any supplied element below. '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN], a: ['target', 'href', 'title', 'rel'], @@ -2701,47 +3413,8 @@ u: [], ul: [] }; - /** - * A pattern that recognizes a commonly useful subset of URLs that are safe. - * - * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts - */ - - var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^#&/:?]*(?:[#/?]|$))/gi; - /** - * A pattern that matches safe data URLs. Only matches image, video and audio types. - * - * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts - */ - - var DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i; - - function allowedAttribute(attr, allowedAttributeList) { - var attrName = attr.nodeName.toLowerCase(); - - if (allowedAttributeList.indexOf(attrName) !== -1) { - if (uriAttrs.indexOf(attrName) !== -1) { - return Boolean(attr.nodeValue.match(SAFE_URL_PATTERN) || attr.nodeValue.match(DATA_URL_PATTERN)); - } - - return true; - } - - var regExp = allowedAttributeList.filter(function (attrRegex) { - return attrRegex instanceof RegExp; - }); // Check if a regular expression validates the attribute. - - for (var i = 0, len = regExp.length; i < len; i++) { - if (attrName.match(regExp[i])) { - return true; - } - } - - return false; - } - - function sanitizeHtml(unsafeHtml, whiteList, sanitizeFn) { - if (unsafeHtml.length === 0) { + function sanitizeHtml(unsafeHtml, allowList, sanitizeFn) { + if (!unsafeHtml.length) { return unsafeHtml; } @@ -2749,53 +3422,51 @@ return sanitizeFn(unsafeHtml); } - var domParser = new window.DOMParser(); - var createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); - var whitelistKeys = Object.keys(whiteList); - var elements = [].slice.call(createdDocument.body.querySelectorAll('*')); + const domParser = new window.DOMParser(); + const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); + const allowlistKeys = Object.keys(allowList); + const elements = [].concat(...createdDocument.body.querySelectorAll('*')); - var _loop = function _loop(i, len) { - var el = elements[i]; - var elName = el.nodeName.toLowerCase(); + for (let i = 0, len = elements.length; i < len; i++) { + const el = elements[i]; + const elName = el.nodeName.toLowerCase(); - if (whitelistKeys.indexOf(el.nodeName.toLowerCase()) === -1) { + if (!allowlistKeys.includes(elName)) { el.parentNode.removeChild(el); - return "continue"; + continue; } - var attributeList = [].slice.call(el.attributes); - var whitelistedAttributes = [].concat(whiteList['*'] || [], whiteList[elName] || []); - attributeList.forEach(function (attr) { - if (!allowedAttribute(attr, whitelistedAttributes)) { + const attributeList = [].concat(...el.attributes); + const allowedAttributes = [].concat(allowList['*'] || [], allowList[elName] || []); + attributeList.forEach(attr => { + if (!allowedAttribute(attr, allowedAttributes)) { el.removeAttribute(attr.nodeName); } }); - }; - - for (var i = 0, len = elements.length; i < len; i++) { - var _ret = _loop(i); - - if (_ret === "continue") continue; } return createdDocument.body.innerHTML; } /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): tooltip.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ - var NAME$6 = 'tooltip'; - var VERSION$6 = '4.6.0'; - var DATA_KEY$6 = 'bs.tooltip'; - var EVENT_KEY$6 = "." + DATA_KEY$6; - var JQUERY_NO_CONFLICT$6 = $__default['default'].fn[NAME$6]; - var CLASS_PREFIX = 'bs-tooltip'; - var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g'); - var DISALLOWED_ATTRIBUTES = ['sanitize', 'whiteList', 'sanitizeFn']; - var DefaultType$4 = { + const NAME$4 = 'tooltip'; + const DATA_KEY$4 = 'bs.tooltip'; + const EVENT_KEY$4 = `.${DATA_KEY$4}`; + const CLASS_PREFIX$1 = 'bs-tooltip'; + const BSCLS_PREFIX_REGEX$1 = new RegExp(`(^|\\s)${CLASS_PREFIX$1}\\S+`, 'g'); + const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']); + const DefaultType$3 = { animation: 'boolean', template: 'string', title: '(string|element|function)', @@ -2804,76 +3475,77 @@ html: 'boolean', selector: '(string|boolean)', placement: '(string|function)', - offset: '(number|string|function)', + offset: '(array|string|function)', container: '(string|element|boolean)', - fallbackPlacement: '(string|array)', + fallbackPlacements: 'array', boundary: '(string|element)', customClass: '(string|function)', sanitize: 'boolean', sanitizeFn: '(null|function)', - whiteList: 'object', - popperConfig: '(null|object)' + allowList: 'object', + popperConfig: '(null|object|function)' }; - var AttachmentMap = { + const AttachmentMap = { AUTO: 'auto', TOP: 'top', - RIGHT: 'right', + RIGHT: isRTL() ? 'left' : 'right', BOTTOM: 'bottom', - LEFT: 'left' + LEFT: isRTL() ? 'right' : 'left' }; - var Default$4 = { + const Default$3 = { animation: true, - template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>', + template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>', trigger: 'hover focus', title: '', delay: 0, html: false, selector: false, placement: 'top', - offset: 0, + offset: [0, 0], container: false, - fallbackPlacement: 'flip', - boundary: 'scrollParent', + fallbackPlacements: ['top', 'right', 'bottom', 'left'], + boundary: 'clippingParents', customClass: '', sanitize: true, sanitizeFn: null, - whiteList: DefaultWhitelist, + allowList: DefaultAllowlist, popperConfig: null }; - var HOVER_STATE_SHOW = 'show'; - var HOVER_STATE_OUT = 'out'; - var Event = { - HIDE: "hide" + EVENT_KEY$6, - HIDDEN: "hidden" + EVENT_KEY$6, - SHOW: "show" + EVENT_KEY$6, - SHOWN: "shown" + EVENT_KEY$6, - INSERTED: "inserted" + EVENT_KEY$6, - CLICK: "click" + EVENT_KEY$6, - FOCUSIN: "focusin" + EVENT_KEY$6, - FOCUSOUT: "focusout" + EVENT_KEY$6, - MOUSEENTER: "mouseenter" + EVENT_KEY$6, - MOUSELEAVE: "mouseleave" + EVENT_KEY$6 + const Event$2 = { + HIDE: `hide${EVENT_KEY$4}`, + HIDDEN: `hidden${EVENT_KEY$4}`, + SHOW: `show${EVENT_KEY$4}`, + SHOWN: `shown${EVENT_KEY$4}`, + INSERTED: `inserted${EVENT_KEY$4}`, + CLICK: `click${EVENT_KEY$4}`, + FOCUSIN: `focusin${EVENT_KEY$4}`, + FOCUSOUT: `focusout${EVENT_KEY$4}`, + MOUSEENTER: `mouseenter${EVENT_KEY$4}`, + MOUSELEAVE: `mouseleave${EVENT_KEY$4}` }; - var CLASS_NAME_FADE$2 = 'fade'; - var CLASS_NAME_SHOW$4 = 'show'; - var SELECTOR_TOOLTIP_INNER = '.tooltip-inner'; - var SELECTOR_ARROW = '.arrow'; - var TRIGGER_HOVER = 'hover'; - var TRIGGER_FOCUS = 'focus'; - var TRIGGER_CLICK = 'click'; - var TRIGGER_MANUAL = 'manual'; + const CLASS_NAME_FADE$3 = 'fade'; + const CLASS_NAME_MODAL = 'modal'; + const CLASS_NAME_SHOW$3 = 'show'; + const HOVER_STATE_SHOW = 'show'; + const HOVER_STATE_OUT = 'out'; + const SELECTOR_TOOLTIP_INNER = '.tooltip-inner'; + const TRIGGER_HOVER = 'hover'; + const TRIGGER_FOCUS = 'focus'; + const TRIGGER_CLICK = 'click'; + const TRIGGER_MANUAL = 'manual'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ - var Tooltip = /*#__PURE__*/function () { - function Tooltip(element, config) { - if (typeof Popper__default['default'] === 'undefined') { + class Tooltip extends BaseComponent { + constructor(element, config) { + if (typeof Popper__namespace === 'undefined') { throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)'); - } // private + } + super(element); // private this._isEnabled = true; this._timeout = 0; @@ -2881,42 +3553,49 @@ this._activeTrigger = {}; this._popper = null; // Protected - this.element = element; - this.config = this._getConfig(config); + this._config = this._getConfig(config); this.tip = null; this._setListeners(); } // Getters - var _proto = Tooltip.prototype; + static get Default() { + return Default$3; + } + + static get NAME() { + return NAME$4; + } + + static get Event() { + return Event$2; + } + + static get DefaultType() { + return DefaultType$3; + } // Public + - // Public - _proto.enable = function enable() { + enable() { this._isEnabled = true; - }; + } - _proto.disable = function disable() { + disable() { this._isEnabled = false; - }; + } - _proto.toggleEnabled = function toggleEnabled() { + toggleEnabled() { this._isEnabled = !this._isEnabled; - }; + } - _proto.toggle = function toggle(event) { + toggle(event) { if (!this._isEnabled) { return; } if (event) { - var dataKey = this.constructor.DATA_KEY; - var context = $__default['default'](event.currentTarget).data(dataKey); - - if (!context) { - context = new this.constructor(event.currentTarget, this._getDelegateConfig()); - $__default['default'](event.currentTarget).data(dataKey, context); - } + const context = this._initializeOnDelegatedTarget(event); context._activeTrigger.click = !context._activeTrigger.click; @@ -2926,7 +3605,7 @@ context._leave(null, context); } } else { - if ($__default['default'](this.getTipElement()).hasClass(CLASS_NAME_SHOW$4)) { + if (this.getTipElement().classList.contains(CLASS_NAME_SHOW$3)) { this._leave(null, this); return; @@ -2934,348 +3613,372 @@ this._enter(null, this); } - }; + } - _proto.dispose = function dispose() { + dispose() { clearTimeout(this._timeout); - $__default['default'].removeData(this.element, this.constructor.DATA_KEY); - $__default['default'](this.element).off(this.constructor.EVENT_KEY); - $__default['default'](this.element).closest('.modal').off('hide.bs.modal', this._hideModalHandler); + EventHandler.off(this._element.closest(`.${CLASS_NAME_MODAL}`), 'hide.bs.modal', this._hideModalHandler); - if (this.tip) { - $__default['default'](this.tip).remove(); + if (this.tip && this.tip.parentNode) { + this.tip.parentNode.removeChild(this.tip); } - this._isEnabled = null; - this._timeout = null; - this._hoverState = null; - this._activeTrigger = null; - if (this._popper) { this._popper.destroy(); } - this._popper = null; - this.element = null; - this.config = null; - this.tip = null; - }; - - _proto.show = function show() { - var _this = this; + super.dispose(); + } - if ($__default['default'](this.element).css('display') === 'none') { + show() { + if (this._element.style.display === 'none') { throw new Error('Please use show on visible elements'); } - var showEvent = $__default['default'].Event(this.constructor.Event.SHOW); + if (!(this.isWithContent() && this._isEnabled)) { + return; + } - if (this.isWithContent() && this._isEnabled) { - $__default['default'](this.element).trigger(showEvent); - var shadowRoot = Util.findShadowRoot(this.element); - var isInTheDom = $__default['default'].contains(shadowRoot !== null ? shadowRoot : this.element.ownerDocument.documentElement, this.element); + const showEvent = EventHandler.trigger(this._element, this.constructor.Event.SHOW); + const shadowRoot = findShadowRoot(this._element); + const isInTheDom = shadowRoot === null ? this._element.ownerDocument.documentElement.contains(this._element) : shadowRoot.contains(this._element); - if (showEvent.isDefaultPrevented() || !isInTheDom) { - return; - } + if (showEvent.defaultPrevented || !isInTheDom) { + return; + } - var tip = this.getTipElement(); - var tipId = Util.getUID(this.constructor.NAME); - tip.setAttribute('id', tipId); - this.element.setAttribute('aria-describedby', tipId); - this.setContent(); + const tip = this.getTipElement(); + const tipId = getUID(this.constructor.NAME); + tip.setAttribute('id', tipId); - if (this.config.animation) { - $__default['default'](tip).addClass(CLASS_NAME_FADE$2); - } + this._element.setAttribute('aria-describedby', tipId); - var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement; + this.setContent(); - var attachment = this._getAttachment(placement); + if (this._config.animation) { + tip.classList.add(CLASS_NAME_FADE$3); + } - this.addAttachmentClass(attachment); + const placement = typeof this._config.placement === 'function' ? this._config.placement.call(this, tip, this._element) : this._config.placement; - var container = this._getContainer(); + const attachment = this._getAttachment(placement); - $__default['default'](tip).data(this.constructor.DATA_KEY, this); + this._addAttachmentClass(attachment); - if (!$__default['default'].contains(this.element.ownerDocument.documentElement, this.tip)) { - $__default['default'](tip).appendTo(container); - } + const { + container + } = this._config; + Data.set(tip, this.constructor.DATA_KEY, this); - $__default['default'](this.element).trigger(this.constructor.Event.INSERTED); - this._popper = new Popper__default['default'](this.element, tip, this._getPopperConfig(attachment)); - $__default['default'](tip).addClass(CLASS_NAME_SHOW$4); - $__default['default'](tip).addClass(this.config.customClass); // If this is a touch-enabled device we add extra - // empty mouseover listeners to the body's immediate children; - // only needed because of broken event delegation on iOS - // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html + if (!this._element.ownerDocument.documentElement.contains(this.tip)) { + container.appendChild(tip); + EventHandler.trigger(this._element, this.constructor.Event.INSERTED); + } - if ('ontouchstart' in document.documentElement) { - $__default['default'](document.body).children().on('mouseover', null, $__default['default'].noop); - } + if (this._popper) { + this._popper.update(); + } else { + this._popper = Popper__namespace.createPopper(this._element, tip, this._getPopperConfig(attachment)); + } - var complete = function complete() { - if (_this.config.animation) { - _this._fixTransition(); - } + tip.classList.add(CLASS_NAME_SHOW$3); + const customClass = typeof this._config.customClass === 'function' ? this._config.customClass() : this._config.customClass; - var prevHoverState = _this._hoverState; - _this._hoverState = null; - $__default['default'](_this.element).trigger(_this.constructor.Event.SHOWN); + if (customClass) { + tip.classList.add(...customClass.split(' ')); + } // If this is a touch-enabled device we add extra + // empty mouseover listeners to the body's immediate children; + // only needed because of broken event delegation on iOS + // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html - if (prevHoverState === HOVER_STATE_OUT) { - _this._leave(null, _this); - } - }; - if ($__default['default'](this.tip).hasClass(CLASS_NAME_FADE$2)) { - var transitionDuration = Util.getTransitionDurationFromElement(this.tip); - $__default['default'](this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); - } else { - complete(); + if ('ontouchstart' in document.documentElement) { + [].concat(...document.body.children).forEach(element => { + EventHandler.on(element, 'mouseover', noop); + }); + } + + const complete = () => { + const prevHoverState = this._hoverState; + this._hoverState = null; + EventHandler.trigger(this._element, this.constructor.Event.SHOWN); + + if (prevHoverState === HOVER_STATE_OUT) { + this._leave(null, this); } + }; + + const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE$3); + + this._queueCallback(complete, this.tip, isAnimated); + } + + hide() { + if (!this._popper) { + return; } - }; - _proto.hide = function hide(callback) { - var _this2 = this; + const tip = this.getTipElement(); - var tip = this.getTipElement(); - var hideEvent = $__default['default'].Event(this.constructor.Event.HIDE); + const complete = () => { + if (this._isWithActiveTrigger()) { + return; + } - var complete = function complete() { - if (_this2._hoverState !== HOVER_STATE_SHOW && tip.parentNode) { + if (this._hoverState !== HOVER_STATE_SHOW && tip.parentNode) { tip.parentNode.removeChild(tip); } - _this2._cleanTipClass(); + this._cleanTipClass(); - _this2.element.removeAttribute('aria-describedby'); + this._element.removeAttribute('aria-describedby'); - $__default['default'](_this2.element).trigger(_this2.constructor.Event.HIDDEN); + EventHandler.trigger(this._element, this.constructor.Event.HIDDEN); - if (_this2._popper !== null) { - _this2._popper.destroy(); - } + if (this._popper) { + this._popper.destroy(); - if (callback) { - callback(); + this._popper = null; } }; - $__default['default'](this.element).trigger(hideEvent); + const hideEvent = EventHandler.trigger(this._element, this.constructor.Event.HIDE); - if (hideEvent.isDefaultPrevented()) { + if (hideEvent.defaultPrevented) { return; } - $__default['default'](tip).removeClass(CLASS_NAME_SHOW$4); // If this is a touch-enabled device we remove the extra + tip.classList.remove(CLASS_NAME_SHOW$3); // If this is a touch-enabled device we remove the extra // empty mouseover listeners we added for iOS support if ('ontouchstart' in document.documentElement) { - $__default['default'](document.body).children().off('mouseover', null, $__default['default'].noop); + [].concat(...document.body.children).forEach(element => EventHandler.off(element, 'mouseover', noop)); } this._activeTrigger[TRIGGER_CLICK] = false; this._activeTrigger[TRIGGER_FOCUS] = false; this._activeTrigger[TRIGGER_HOVER] = false; + const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE$3); - if ($__default['default'](this.tip).hasClass(CLASS_NAME_FADE$2)) { - var transitionDuration = Util.getTransitionDurationFromElement(tip); - $__default['default'](tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); - } else { - complete(); - } + this._queueCallback(complete, this.tip, isAnimated); this._hoverState = ''; - }; + } - _proto.update = function update() { + update() { if (this._popper !== null) { - this._popper.scheduleUpdate(); + this._popper.update(); } } // Protected - ; - _proto.isWithContent = function isWithContent() { + + isWithContent() { return Boolean(this.getTitle()); - }; + } - _proto.addAttachmentClass = function addAttachmentClass(attachment) { - $__default['default'](this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment); - }; + getTipElement() { + if (this.tip) { + return this.tip; + } - _proto.getTipElement = function getTipElement() { - this.tip = this.tip || $__default['default'](this.config.template)[0]; + const element = document.createElement('div'); + element.innerHTML = this._config.template; + this.tip = element.children[0]; return this.tip; - }; + } - _proto.setContent = function setContent() { - var tip = this.getTipElement(); - this.setElementContent($__default['default'](tip.querySelectorAll(SELECTOR_TOOLTIP_INNER)), this.getTitle()); - $__default['default'](tip).removeClass(CLASS_NAME_FADE$2 + " " + CLASS_NAME_SHOW$4); - }; + setContent() { + const tip = this.getTipElement(); + this.setElementContent(SelectorEngine.findOne(SELECTOR_TOOLTIP_INNER, tip), this.getTitle()); + tip.classList.remove(CLASS_NAME_FADE$3, CLASS_NAME_SHOW$3); + } - _proto.setElementContent = function setElementContent($element, content) { - if (typeof content === 'object' && (content.nodeType || content.jquery)) { - // Content is a DOM node or a jQuery - if (this.config.html) { - if (!$__default['default'](content).parent().is($element)) { - $element.empty().append(content); + setElementContent(element, content) { + if (element === null) { + return; + } + + if (isElement(content)) { + content = getElement(content); // content is a DOM node or a jQuery + + if (this._config.html) { + if (content.parentNode !== element) { + element.innerHTML = ''; + element.appendChild(content); } } else { - $element.text($__default['default'](content).text()); + element.textContent = content.textContent; } return; } - if (this.config.html) { - if (this.config.sanitize) { - content = sanitizeHtml(content, this.config.whiteList, this.config.sanitizeFn); + if (this._config.html) { + if (this._config.sanitize) { + content = sanitizeHtml(content, this._config.allowList, this._config.sanitizeFn); } - $element.html(content); + element.innerHTML = content; } else { - $element.text(content); + element.textContent = content; } - }; + } - _proto.getTitle = function getTitle() { - var title = this.element.getAttribute('data-original-title'); + getTitle() { + let title = this._element.getAttribute('data-bs-original-title'); if (!title) { - title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title; + title = typeof this._config.title === 'function' ? this._config.title.call(this._element) : this._config.title; } return title; - } // Private - ; + } - _proto._getPopperConfig = function _getPopperConfig(attachment) { - var _this3 = this; + updateAttachment(attachment) { + if (attachment === 'right') { + return 'end'; + } - var defaultBsConfig = { - placement: attachment, - modifiers: { - offset: this._getOffset(), - flip: { - behavior: this.config.fallbackPlacement - }, - arrow: { - element: SELECTOR_ARROW - }, - preventOverflow: { - boundariesElement: this.config.boundary - } - }, - onCreate: function onCreate(data) { - if (data.originalPlacement !== data.placement) { - _this3._handlePopperPlacementChange(data); - } - }, - onUpdate: function onUpdate(data) { - return _this3._handlePopperPlacementChange(data); - } - }; - return _extends({}, defaultBsConfig, this.config.popperConfig); - }; + if (attachment === 'left') { + return 'start'; + } - _proto._getOffset = function _getOffset() { - var _this4 = this; + return attachment; + } // Private - var offset = {}; - if (typeof this.config.offset === 'function') { - offset.fn = function (data) { - data.offsets = _extends({}, data.offsets, _this4.config.offset(data.offsets, _this4.element) || {}); - return data; - }; - } else { - offset.offset = this.config.offset; + _initializeOnDelegatedTarget(event, context) { + const dataKey = this.constructor.DATA_KEY; + context = context || Data.get(event.delegateTarget, dataKey); + + if (!context) { + context = new this.constructor(event.delegateTarget, this._getDelegateConfig()); + Data.set(event.delegateTarget, dataKey, context); } - return offset; - }; + return context; + } - _proto._getContainer = function _getContainer() { - if (this.config.container === false) { - return document.body; + _getOffset() { + const { + offset + } = this._config; + + if (typeof offset === 'string') { + return offset.split(',').map(val => Number.parseInt(val, 10)); } - if (Util.isElement(this.config.container)) { - return $__default['default'](this.config.container); + if (typeof offset === 'function') { + return popperData => offset(popperData, this._element); } - return $__default['default'](document).find(this.config.container); - }; + return offset; + } + + _getPopperConfig(attachment) { + const defaultBsPopperConfig = { + placement: attachment, + 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: 'onChange', + enabled: true, + phase: 'afterWrite', + fn: data => this._handlePopperPlacementChange(data) + }], + onFirstUpdate: data => { + if (data.options.placement !== data.placement) { + this._handlePopperPlacementChange(data); + } + } + }; + return { ...defaultBsPopperConfig, + ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig) + }; + } - _proto._getAttachment = function _getAttachment(placement) { + _addAttachmentClass(attachment) { + this.getTipElement().classList.add(`${CLASS_PREFIX$1}-${this.updateAttachment(attachment)}`); + } + + _getAttachment(placement) { return AttachmentMap[placement.toUpperCase()]; - }; + } - _proto._setListeners = function _setListeners() { - var _this5 = this; + _setListeners() { + const triggers = this._config.trigger.split(' '); - var triggers = this.config.trigger.split(' '); - triggers.forEach(function (trigger) { + triggers.forEach(trigger => { if (trigger === 'click') { - $__default['default'](_this5.element).on(_this5.constructor.Event.CLICK, _this5.config.selector, function (event) { - return _this5.toggle(event); - }); + EventHandler.on(this._element, this.constructor.Event.CLICK, this._config.selector, event => this.toggle(event)); } else if (trigger !== TRIGGER_MANUAL) { - var eventIn = trigger === TRIGGER_HOVER ? _this5.constructor.Event.MOUSEENTER : _this5.constructor.Event.FOCUSIN; - var eventOut = trigger === TRIGGER_HOVER ? _this5.constructor.Event.MOUSELEAVE : _this5.constructor.Event.FOCUSOUT; - $__default['default'](_this5.element).on(eventIn, _this5.config.selector, function (event) { - return _this5._enter(event); - }).on(eventOut, _this5.config.selector, function (event) { - return _this5._leave(event); - }); + const eventIn = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSEENTER : this.constructor.Event.FOCUSIN; + const eventOut = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSELEAVE : this.constructor.Event.FOCUSOUT; + EventHandler.on(this._element, eventIn, this._config.selector, event => this._enter(event)); + EventHandler.on(this._element, eventOut, this._config.selector, event => this._leave(event)); } }); - this._hideModalHandler = function () { - if (_this5.element) { - _this5.hide(); + this._hideModalHandler = () => { + if (this._element) { + this.hide(); } }; - $__default['default'](this.element).closest('.modal').on('hide.bs.modal', this._hideModalHandler); + EventHandler.on(this._element.closest(`.${CLASS_NAME_MODAL}`), 'hide.bs.modal', this._hideModalHandler); - if (this.config.selector) { - this.config = _extends({}, this.config, { + if (this._config.selector) { + this._config = { ...this._config, trigger: 'manual', selector: '' - }); + }; } else { this._fixTitle(); } - }; + } - _proto._fixTitle = function _fixTitle() { - var titleType = typeof this.element.getAttribute('data-original-title'); + _fixTitle() { + const title = this._element.getAttribute('title'); - if (this.element.getAttribute('title') || titleType !== 'string') { - this.element.setAttribute('data-original-title', this.element.getAttribute('title') || ''); - this.element.setAttribute('title', ''); - } - }; + const originalTitleType = typeof this._element.getAttribute('data-bs-original-title'); - _proto._enter = function _enter(event, context) { - var dataKey = this.constructor.DATA_KEY; - context = context || $__default['default'](event.currentTarget).data(dataKey); + if (title || originalTitleType !== 'string') { + this._element.setAttribute('data-bs-original-title', title || ''); - if (!context) { - context = new this.constructor(event.currentTarget, this._getDelegateConfig()); - $__default['default'](event.currentTarget).data(dataKey, context); + if (title && !this._element.getAttribute('aria-label') && !this._element.textContent) { + this._element.setAttribute('aria-label', title); + } + + this._element.setAttribute('title', ''); } + } + + _enter(event, context) { + context = this._initializeOnDelegatedTarget(event, context); if (event) { context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true; } - if ($__default['default'](context.getTipElement()).hasClass(CLASS_NAME_SHOW$4) || context._hoverState === HOVER_STATE_SHOW) { + if (context.getTipElement().classList.contains(CLASS_NAME_SHOW$3) || context._hoverState === HOVER_STATE_SHOW) { context._hoverState = HOVER_STATE_SHOW; return; } @@ -3283,29 +3986,23 @@ clearTimeout(context._timeout); context._hoverState = HOVER_STATE_SHOW; - if (!context.config.delay || !context.config.delay.show) { + if (!context._config.delay || !context._config.delay.show) { context.show(); return; } - context._timeout = setTimeout(function () { + context._timeout = setTimeout(() => { if (context._hoverState === HOVER_STATE_SHOW) { context.show(); } - }, context.config.delay.show); - }; + }, context._config.delay.show); + } - _proto._leave = function _leave(event, context) { - var dataKey = this.constructor.DATA_KEY; - context = context || $__default['default'](event.currentTarget).data(dataKey); - - if (!context) { - context = new this.constructor(event.currentTarget, this._getDelegateConfig()); - $__default['default'](event.currentTarget).data(dataKey, context); - } + _leave(event, context) { + context = this._initializeOnDelegatedTarget(event, context); if (event) { - context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = false; + context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget); } if (context._isWithActiveTrigger()) { @@ -3315,36 +4012,40 @@ clearTimeout(context._timeout); context._hoverState = HOVER_STATE_OUT; - if (!context.config.delay || !context.config.delay.hide) { + if (!context._config.delay || !context._config.delay.hide) { context.hide(); return; } - context._timeout = setTimeout(function () { + context._timeout = setTimeout(() => { if (context._hoverState === HOVER_STATE_OUT) { context.hide(); } - }, context.config.delay.hide); - }; + }, context._config.delay.hide); + } - _proto._isWithActiveTrigger = function _isWithActiveTrigger() { - for (var trigger in this._activeTrigger) { + _isWithActiveTrigger() { + for (const trigger in this._activeTrigger) { if (this._activeTrigger[trigger]) { return true; } } return false; - }; + } - _proto._getConfig = function _getConfig(config) { - var dataAttributes = $__default['default'](this.element).data(); - Object.keys(dataAttributes).forEach(function (dataAttr) { - if (DISALLOWED_ATTRIBUTES.indexOf(dataAttr) !== -1) { + _getConfig(config) { + const dataAttributes = Manipulator.getDataAttributes(this._element); + Object.keys(dataAttributes).forEach(dataAttr => { + if (DISALLOWED_ATTRIBUTES.has(dataAttr)) { delete dataAttributes[dataAttr]; } }); - config = _extends({}, this.constructor.Default, dataAttributes, typeof config === 'object' && config ? config : {}); + config = { ...this.constructor.Default, + ...dataAttributes, + ...(typeof config === 'object' && config ? config : {}) + }; + config.container = config.container === false ? document.body : getElement(config.container); if (typeof config.delay === 'number') { config.delay = { @@ -3361,68 +4062,60 @@ config.content = config.content.toString(); } - Util.typeCheckConfig(NAME$6, config, this.constructor.DefaultType); + typeCheckConfig(NAME$4, config, this.constructor.DefaultType); if (config.sanitize) { - config.template = sanitizeHtml(config.template, config.whiteList, config.sanitizeFn); + config.template = sanitizeHtml(config.template, config.allowList, config.sanitizeFn); } return config; - }; + } - _proto._getDelegateConfig = function _getDelegateConfig() { - var config = {}; + _getDelegateConfig() { + const config = {}; - if (this.config) { - for (var key in this.config) { - if (this.constructor.Default[key] !== this.config[key]) { - config[key] = this.config[key]; + if (this._config) { + for (const key in this._config) { + if (this.constructor.Default[key] !== this._config[key]) { + config[key] = this._config[key]; } } } return config; - }; + } - _proto._cleanTipClass = function _cleanTipClass() { - var $tip = $__default['default'](this.getTipElement()); - var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX); + _cleanTipClass() { + const tip = this.getTipElement(); + const tabClass = tip.getAttribute('class').match(BSCLS_PREFIX_REGEX$1); - if (tabClass !== null && tabClass.length) { - $tip.removeClass(tabClass.join('')); + if (tabClass !== null && tabClass.length > 0) { + tabClass.map(token => token.trim()).forEach(tClass => tip.classList.remove(tClass)); } - }; - - _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) { - this.tip = popperData.instance.popper; - - this._cleanTipClass(); - - this.addAttachmentClass(this._getAttachment(popperData.placement)); - }; + } - _proto._fixTransition = function _fixTransition() { - var tip = this.getTipElement(); - var initConfigAnimation = this.config.animation; + _handlePopperPlacementChange(popperData) { + const { + state + } = popperData; - if (tip.getAttribute('x-placement') !== null) { + if (!state) { return; } - $__default['default'](tip).removeClass(CLASS_NAME_FADE$2); - this.config.animation = false; - this.hide(); - this.show(); - this.config.animation = initConfigAnimation; + this.tip = state.elements.popper; + + this._cleanTipClass(); + + this._addAttachmentClass(this._getAttachment(state.placement)); } // Static - ; - Tooltip._jQueryInterface = function _jQueryInterface(config) { + + static jQueryInterface(config) { return this.each(function () { - var $element = $__default['default'](this); - var data = $element.data(DATA_KEY$6); + let data = Data.get(this, DATA_KEY$4); - var _config = typeof config === 'object' && config; + const _config = typeof config === 'object' && config; if (!data && /dispose|hide/.test(config)) { return; @@ -3430,178 +4123,140 @@ if (!data) { data = new Tooltip(this, _config); - $element.data(DATA_KEY$6, data); } if (typeof config === 'string') { if (typeof data[config] === 'undefined') { - throw new TypeError("No method named \"" + config + "\""); + throw new TypeError(`No method named "${config}"`); } data[config](); } }); - }; + } - _createClass(Tooltip, null, [{ - key: "VERSION", - get: function get() { - return VERSION$6; - } - }, { - key: "Default", - get: function get() { - return Default$4; - } - }, { - key: "NAME", - get: function get() { - return NAME$6; - } - }, { - key: "DATA_KEY", - get: function get() { - return DATA_KEY$6; - } - }, { - key: "Event", - get: function get() { - return Event; - } - }, { - key: "EVENT_KEY", - get: function get() { - return EVENT_KEY$6; - } - }, { - key: "DefaultType", - get: function get() { - return DefaultType$4; - } - }]); - - return Tooltip; - }(); + } /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ + * add .Tooltip to jQuery only if jQuery is present */ - $__default['default'].fn[NAME$6] = Tooltip._jQueryInterface; - $__default['default'].fn[NAME$6].Constructor = Tooltip; - - $__default['default'].fn[NAME$6].noConflict = function () { - $__default['default'].fn[NAME$6] = JQUERY_NO_CONFLICT$6; - return Tooltip._jQueryInterface; - }; + defineJQueryPlugin(Tooltip); /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): popover.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ - var NAME$7 = 'popover'; - var VERSION$7 = '4.6.0'; - var DATA_KEY$7 = 'bs.popover'; - var EVENT_KEY$7 = "." + DATA_KEY$7; - var JQUERY_NO_CONFLICT$7 = $__default['default'].fn[NAME$7]; - var CLASS_PREFIX$1 = 'bs-popover'; - var BSCLS_PREFIX_REGEX$1 = new RegExp("(^|\\s)" + CLASS_PREFIX$1 + "\\S+", 'g'); - - var Default$5 = _extends({}, Tooltip.Default, { + const NAME$3 = 'popover'; + const DATA_KEY$3 = 'bs.popover'; + const EVENT_KEY$3 = `.${DATA_KEY$3}`; + const CLASS_PREFIX = 'bs-popover'; + const BSCLS_PREFIX_REGEX = new RegExp(`(^|\\s)${CLASS_PREFIX}\\S+`, 'g'); + const Default$2 = { ...Tooltip.Default, placement: 'right', + offset: [0, 8], trigger: 'click', content: '', - template: '<div class="popover" role="tooltip">' + '<div class="arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div></div>' - }); - - var DefaultType$5 = _extends({}, Tooltip.DefaultType, { + template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>' + }; + const DefaultType$2 = { ...Tooltip.DefaultType, content: '(string|element|function)' - }); - - var CLASS_NAME_FADE$3 = 'fade'; - var CLASS_NAME_SHOW$5 = 'show'; - var SELECTOR_TITLE = '.popover-header'; - var SELECTOR_CONTENT = '.popover-body'; - var Event$1 = { - HIDE: "hide" + EVENT_KEY$7, - HIDDEN: "hidden" + EVENT_KEY$7, - SHOW: "show" + EVENT_KEY$7, - SHOWN: "shown" + EVENT_KEY$7, - INSERTED: "inserted" + EVENT_KEY$7, - CLICK: "click" + EVENT_KEY$7, - FOCUSIN: "focusin" + EVENT_KEY$7, - FOCUSOUT: "focusout" + EVENT_KEY$7, - MOUSEENTER: "mouseenter" + EVENT_KEY$7, - MOUSELEAVE: "mouseleave" + EVENT_KEY$7 }; + const Event$1 = { + HIDE: `hide${EVENT_KEY$3}`, + HIDDEN: `hidden${EVENT_KEY$3}`, + SHOW: `show${EVENT_KEY$3}`, + SHOWN: `shown${EVENT_KEY$3}`, + INSERTED: `inserted${EVENT_KEY$3}`, + CLICK: `click${EVENT_KEY$3}`, + FOCUSIN: `focusin${EVENT_KEY$3}`, + FOCUSOUT: `focusout${EVENT_KEY$3}`, + MOUSEENTER: `mouseenter${EVENT_KEY$3}`, + MOUSELEAVE: `mouseleave${EVENT_KEY$3}` + }; + const CLASS_NAME_FADE$2 = 'fade'; + const CLASS_NAME_SHOW$2 = 'show'; + const SELECTOR_TITLE = '.popover-header'; + const SELECTOR_CONTENT = '.popover-body'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ - var Popover = /*#__PURE__*/function (_Tooltip) { - _inheritsLoose(Popover, _Tooltip); + class Popover extends Tooltip { + // Getters + static get Default() { + return Default$2; + } - function Popover() { - return _Tooltip.apply(this, arguments) || this; + static get NAME() { + return NAME$3; } - var _proto = Popover.prototype; + static get Event() { + return Event$1; + } - // Overrides - _proto.isWithContent = function isWithContent() { - return this.getTitle() || this._getContent(); - }; + static get DefaultType() { + return DefaultType$2; + } // Overrides - _proto.addAttachmentClass = function addAttachmentClass(attachment) { - $__default['default'](this.getTipElement()).addClass(CLASS_PREFIX$1 + "-" + attachment); - }; - _proto.getTipElement = function getTipElement() { - this.tip = this.tip || $__default['default'](this.config.template)[0]; - return this.tip; - }; + isWithContent() { + return this.getTitle() || this._getContent(); + } - _proto.setContent = function setContent() { - var $tip = $__default['default'](this.getTipElement()); // We use append for html objects to maintain js events + setContent() { + const tip = this.getTipElement(); // we use append for html objects to maintain js events - this.setElementContent($tip.find(SELECTOR_TITLE), this.getTitle()); + this.setElementContent(SelectorEngine.findOne(SELECTOR_TITLE, tip), this.getTitle()); - var content = this._getContent(); + let content = this._getContent(); if (typeof content === 'function') { - content = content.call(this.element); + content = content.call(this._element); } - this.setElementContent($tip.find(SELECTOR_CONTENT), content); - $tip.removeClass(CLASS_NAME_FADE$3 + " " + CLASS_NAME_SHOW$5); + this.setElementContent(SelectorEngine.findOne(SELECTOR_CONTENT, tip), content); + tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2); } // Private - ; - _proto._getContent = function _getContent() { - return this.element.getAttribute('data-content') || this.config.content; - }; - _proto._cleanTipClass = function _cleanTipClass() { - var $tip = $__default['default'](this.getTipElement()); - var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX$1); + _addAttachmentClass(attachment) { + this.getTipElement().classList.add(`${CLASS_PREFIX}-${this.updateAttachment(attachment)}`); + } + + _getContent() { + return this._element.getAttribute('data-bs-content') || this._config.content; + } + + _cleanTipClass() { + const tip = this.getTipElement(); + const tabClass = tip.getAttribute('class').match(BSCLS_PREFIX_REGEX); if (tabClass !== null && tabClass.length > 0) { - $tip.removeClass(tabClass.join('')); + tabClass.map(token => token.trim()).forEach(tClass => tip.classList.remove(tClass)); } } // Static - ; - Popover._jQueryInterface = function _jQueryInterface(config) { + + static jQueryInterface(config) { return this.each(function () { - var data = $__default['default'](this).data(DATA_KEY$7); + let data = Data.get(this, DATA_KEY$3); - var _config = typeof config === 'object' ? config : null; + const _config = typeof config === 'object' ? config : null; if (!data && /dispose|hide/.test(config)) { return; @@ -3609,237 +4264,184 @@ if (!data) { data = new Popover(this, _config); - $__default['default'](this).data(DATA_KEY$7, data); + Data.set(this, DATA_KEY$3, data); } if (typeof config === 'string') { if (typeof data[config] === 'undefined') { - throw new TypeError("No method named \"" + config + "\""); + throw new TypeError(`No method named "${config}"`); } data[config](); } }); - }; + } - _createClass(Popover, null, [{ - key: "VERSION", - // Getters - get: function get() { - return VERSION$7; - } - }, { - key: "Default", - get: function get() { - return Default$5; - } - }, { - key: "NAME", - get: function get() { - return NAME$7; - } - }, { - key: "DATA_KEY", - get: function get() { - return DATA_KEY$7; - } - }, { - key: "Event", - get: function get() { - return Event$1; - } - }, { - key: "EVENT_KEY", - get: function get() { - return EVENT_KEY$7; - } - }, { - key: "DefaultType", - get: function get() { - return DefaultType$5; - } - }]); - - return Popover; - }(Tooltip); + } /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ + * add .Popover to jQuery only if jQuery is present */ - $__default['default'].fn[NAME$7] = Popover._jQueryInterface; - $__default['default'].fn[NAME$7].Constructor = Popover; - - $__default['default'].fn[NAME$7].noConflict = function () { - $__default['default'].fn[NAME$7] = JQUERY_NO_CONFLICT$7; - return Popover._jQueryInterface; - }; + defineJQueryPlugin(Popover); /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): scrollspy.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ - var NAME$8 = 'scrollspy'; - var VERSION$8 = '4.6.0'; - var DATA_KEY$8 = 'bs.scrollspy'; - var EVENT_KEY$8 = "." + DATA_KEY$8; - var DATA_API_KEY$6 = '.data-api'; - var JQUERY_NO_CONFLICT$8 = $__default['default'].fn[NAME$8]; - var Default$6 = { + const NAME$2 = 'scrollspy'; + const DATA_KEY$2 = 'bs.scrollspy'; + const EVENT_KEY$2 = `.${DATA_KEY$2}`; + const DATA_API_KEY$1 = '.data-api'; + const Default$1 = { offset: 10, method: 'auto', target: '' }; - var DefaultType$6 = { + const DefaultType$1 = { offset: 'number', method: 'string', target: '(string|element)' }; - var EVENT_ACTIVATE = "activate" + EVENT_KEY$8; - var EVENT_SCROLL = "scroll" + EVENT_KEY$8; - var EVENT_LOAD_DATA_API$2 = "load" + EVENT_KEY$8 + DATA_API_KEY$6; - var CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item'; - var CLASS_NAME_ACTIVE$2 = 'active'; - var SELECTOR_DATA_SPY = '[data-spy="scroll"]'; - var SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'; - var SELECTOR_NAV_LINKS = '.nav-link'; - var SELECTOR_NAV_ITEMS = '.nav-item'; - var SELECTOR_LIST_ITEMS = '.list-group-item'; - var SELECTOR_DROPDOWN = '.dropdown'; - var SELECTOR_DROPDOWN_ITEMS = '.dropdown-item'; - var SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'; - var METHOD_OFFSET = 'offset'; - var METHOD_POSITION = 'position'; + const EVENT_ACTIVATE = `activate${EVENT_KEY$2}`; + const EVENT_SCROLL = `scroll${EVENT_KEY$2}`; + const EVENT_LOAD_DATA_API = `load${EVENT_KEY$2}${DATA_API_KEY$1}`; + const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item'; + const CLASS_NAME_ACTIVE$1 = 'active'; + const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]'; + const SELECTOR_NAV_LIST_GROUP$1 = '.nav, .list-group'; + const SELECTOR_NAV_LINKS = '.nav-link'; + const SELECTOR_NAV_ITEMS = '.nav-item'; + const SELECTOR_LIST_ITEMS = '.list-group-item'; + const SELECTOR_DROPDOWN$1 = '.dropdown'; + const SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle'; + const METHOD_OFFSET = 'offset'; + const METHOD_POSITION = 'position'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ - var ScrollSpy = /*#__PURE__*/function () { - function ScrollSpy(element, config) { - var _this = this; - - this._element = element; - this._scrollElement = element.tagName === 'BODY' ? window : element; + class ScrollSpy extends BaseComponent { + constructor(element, config) { + super(element); + this._scrollElement = this._element.tagName === 'BODY' ? window : this._element; this._config = this._getConfig(config); - this._selector = this._config.target + " " + SELECTOR_NAV_LINKS + "," + (this._config.target + " " + SELECTOR_LIST_ITEMS + ",") + (this._config.target + " " + SELECTOR_DROPDOWN_ITEMS); + this._selector = `${this._config.target} ${SELECTOR_NAV_LINKS}, ${this._config.target} ${SELECTOR_LIST_ITEMS}, ${this._config.target} .${CLASS_NAME_DROPDOWN_ITEM}`; this._offsets = []; this._targets = []; this._activeTarget = null; this._scrollHeight = 0; - $__default['default'](this._scrollElement).on(EVENT_SCROLL, function (event) { - return _this._process(event); - }); + EventHandler.on(this._scrollElement, EVENT_SCROLL, () => this._process()); this.refresh(); this._process(); } // Getters - var _proto = ScrollSpy.prototype; + static get Default() { + return Default$1; + } + + static get NAME() { + return NAME$2; + } // Public - // Public - _proto.refresh = function refresh() { - var _this2 = this; - var autoMethod = this._scrollElement === this._scrollElement.window ? METHOD_OFFSET : METHOD_POSITION; - var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method; - var offsetBase = offsetMethod === METHOD_POSITION ? this._getScrollTop() : 0; + refresh() { + const autoMethod = this._scrollElement === this._scrollElement.window ? METHOD_OFFSET : METHOD_POSITION; + const offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method; + const offsetBase = offsetMethod === METHOD_POSITION ? this._getScrollTop() : 0; this._offsets = []; this._targets = []; this._scrollHeight = this._getScrollHeight(); - var targets = [].slice.call(document.querySelectorAll(this._selector)); - targets.map(function (element) { - var target; - var targetSelector = Util.getSelectorFromElement(element); - - if (targetSelector) { - target = document.querySelector(targetSelector); - } + const targets = SelectorEngine.find(this._selector); + targets.map(element => { + const targetSelector = getSelectorFromElement(element); + const target = targetSelector ? SelectorEngine.findOne(targetSelector) : null; if (target) { - var targetBCR = target.getBoundingClientRect(); + const targetBCR = target.getBoundingClientRect(); if (targetBCR.width || targetBCR.height) { - // TODO (fat): remove sketch reliance on jQuery position/offset - return [$__default['default'](target)[offsetMethod]().top + offsetBase, targetSelector]; + return [Manipulator[offsetMethod](target).top + offsetBase, targetSelector]; } } return null; - }).filter(function (item) { - return item; - }).sort(function (a, b) { - return a[0] - b[0]; - }).forEach(function (item) { - _this2._offsets.push(item[0]); - - _this2._targets.push(item[1]); + }).filter(item => item).sort((a, b) => a[0] - b[0]).forEach(item => { + this._offsets.push(item[0]); + + this._targets.push(item[1]); }); - }; + } - _proto.dispose = function dispose() { - $__default['default'].removeData(this._element, DATA_KEY$8); - $__default['default'](this._scrollElement).off(EVENT_KEY$8); - this._element = null; - this._scrollElement = null; - this._config = null; - this._selector = null; - this._offsets = null; - this._targets = null; - this._activeTarget = null; - this._scrollHeight = null; + dispose() { + EventHandler.off(this._scrollElement, EVENT_KEY$2); + super.dispose(); } // Private - ; - _proto._getConfig = function _getConfig(config) { - config = _extends({}, Default$6, typeof config === 'object' && config ? config : {}); - if (typeof config.target !== 'string' && Util.isElement(config.target)) { - var id = $__default['default'](config.target).attr('id'); + _getConfig(config) { + config = { ...Default$1, + ...Manipulator.getDataAttributes(this._element), + ...(typeof config === 'object' && config ? config : {}) + }; + + if (typeof config.target !== 'string' && isElement(config.target)) { + let { + id + } = config.target; if (!id) { - id = Util.getUID(NAME$8); - $__default['default'](config.target).attr('id', id); + id = getUID(NAME$2); + config.target.id = id; } - config.target = "#" + id; + config.target = `#${id}`; } - Util.typeCheckConfig(NAME$8, config, DefaultType$6); + typeCheckConfig(NAME$2, config, DefaultType$1); return config; - }; + } - _proto._getScrollTop = function _getScrollTop() { + _getScrollTop() { return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop; - }; + } - _proto._getScrollHeight = function _getScrollHeight() { + _getScrollHeight() { return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight); - }; + } - _proto._getOffsetHeight = function _getOffsetHeight() { + _getOffsetHeight() { return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height; - }; + } - _proto._process = function _process() { - var scrollTop = this._getScrollTop() + this._config.offset; + _process() { + const scrollTop = this._getScrollTop() + this._config.offset; - var scrollHeight = this._getScrollHeight(); + const scrollHeight = this._getScrollHeight(); - var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight(); + const maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight(); if (this._scrollHeight !== scrollHeight) { this.refresh(); } if (scrollTop >= maxScroll) { - var target = this._targets[this._targets.length - 1]; + const target = this._targets[this._targets.length - 1]; if (this._activeTarget !== target) { this._activate(target); @@ -3856,88 +4458,68 @@ return; } - for (var i = this._offsets.length; i--;) { - var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]); + for (let i = this._offsets.length; i--;) { + const isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]); if (isActiveTarget) { this._activate(this._targets[i]); } } - }; + } - _proto._activate = function _activate(target) { + _activate(target) { this._activeTarget = target; this._clear(); - var queries = this._selector.split(',').map(function (selector) { - return selector + "[data-target=\"" + target + "\"]," + selector + "[href=\"" + target + "\"]"; - }); + const queries = this._selector.split(',').map(selector => `${selector}[data-bs-target="${target}"],${selector}[href="${target}"]`); - var $link = $__default['default']([].slice.call(document.querySelectorAll(queries.join(',')))); + const link = SelectorEngine.findOne(queries.join(',')); - if ($link.hasClass(CLASS_NAME_DROPDOWN_ITEM)) { - $link.closest(SELECTOR_DROPDOWN).find(SELECTOR_DROPDOWN_TOGGLE).addClass(CLASS_NAME_ACTIVE$2); - $link.addClass(CLASS_NAME_ACTIVE$2); + if (link.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) { + SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, link.closest(SELECTOR_DROPDOWN$1)).classList.add(CLASS_NAME_ACTIVE$1); + link.classList.add(CLASS_NAME_ACTIVE$1); } else { // Set triggered link as active - $link.addClass(CLASS_NAME_ACTIVE$2); // Set triggered links parents as active - // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor - - $link.parents(SELECTOR_NAV_LIST_GROUP).prev(SELECTOR_NAV_LINKS + ", " + SELECTOR_LIST_ITEMS).addClass(CLASS_NAME_ACTIVE$2); // Handle special case when .nav-link is inside .nav-item - - $link.parents(SELECTOR_NAV_LIST_GROUP).prev(SELECTOR_NAV_ITEMS).children(SELECTOR_NAV_LINKS).addClass(CLASS_NAME_ACTIVE$2); + link.classList.add(CLASS_NAME_ACTIVE$1); + SelectorEngine.parents(link, SELECTOR_NAV_LIST_GROUP$1).forEach(listGroup => { + // Set triggered links parents as active + // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor + SelectorEngine.prev(listGroup, `${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`).forEach(item => item.classList.add(CLASS_NAME_ACTIVE$1)); // Handle special case when .nav-link is inside .nav-item + + SelectorEngine.prev(listGroup, SELECTOR_NAV_ITEMS).forEach(navItem => { + SelectorEngine.children(navItem, SELECTOR_NAV_LINKS).forEach(item => item.classList.add(CLASS_NAME_ACTIVE$1)); + }); + }); } - $__default['default'](this._scrollElement).trigger(EVENT_ACTIVATE, { + EventHandler.trigger(this._scrollElement, EVENT_ACTIVATE, { relatedTarget: target }); - }; + } - _proto._clear = function _clear() { - [].slice.call(document.querySelectorAll(this._selector)).filter(function (node) { - return node.classList.contains(CLASS_NAME_ACTIVE$2); - }).forEach(function (node) { - return node.classList.remove(CLASS_NAME_ACTIVE$2); - }); + _clear() { + SelectorEngine.find(this._selector).filter(node => node.classList.contains(CLASS_NAME_ACTIVE$1)).forEach(node => node.classList.remove(CLASS_NAME_ACTIVE$1)); } // Static - ; - ScrollSpy._jQueryInterface = function _jQueryInterface(config) { - return this.each(function () { - var data = $__default['default'](this).data(DATA_KEY$8); - var _config = typeof config === 'object' && config; + static jQueryInterface(config) { + return this.each(function () { + const data = ScrollSpy.getInstance(this) || new ScrollSpy(this, typeof config === 'object' ? config : {}); - if (!data) { - data = new ScrollSpy(this, _config); - $__default['default'](this).data(DATA_KEY$8, data); + if (typeof config !== 'string') { + return; } - if (typeof config === 'string') { - if (typeof data[config] === 'undefined') { - throw new TypeError("No method named \"" + config + "\""); - } - - data[config](); + if (typeof data[config] === 'undefined') { + throw new TypeError(`No method named "${config}"`); } - }); - }; - _createClass(ScrollSpy, null, [{ - key: "VERSION", - get: function get() { - return VERSION$8; - } - }, { - key: "Default", - get: function get() { - return Default$6; - } - }]); + data[config](); + }); + } - return ScrollSpy; - }(); + } /** * ------------------------------------------------------------------------ * Data Api implementation @@ -3945,124 +4527,99 @@ */ - $__default['default'](window).on(EVENT_LOAD_DATA_API$2, function () { - var scrollSpys = [].slice.call(document.querySelectorAll(SELECTOR_DATA_SPY)); - var scrollSpysLength = scrollSpys.length; - - for (var i = scrollSpysLength; i--;) { - var $spy = $__default['default'](scrollSpys[i]); - - ScrollSpy._jQueryInterface.call($spy, $spy.data()); - } + EventHandler.on(window, EVENT_LOAD_DATA_API, () => { + SelectorEngine.find(SELECTOR_DATA_SPY).forEach(spy => new ScrollSpy(spy)); }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ + * add .ScrollSpy to jQuery only if jQuery is present */ - $__default['default'].fn[NAME$8] = ScrollSpy._jQueryInterface; - $__default['default'].fn[NAME$8].Constructor = ScrollSpy; - - $__default['default'].fn[NAME$8].noConflict = function () { - $__default['default'].fn[NAME$8] = JQUERY_NO_CONFLICT$8; - return ScrollSpy._jQueryInterface; - }; + defineJQueryPlugin(ScrollSpy); /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): tab.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ - var NAME$9 = 'tab'; - var VERSION$9 = '4.6.0'; - var DATA_KEY$9 = 'bs.tab'; - var EVENT_KEY$9 = "." + DATA_KEY$9; - var DATA_API_KEY$7 = '.data-api'; - var JQUERY_NO_CONFLICT$9 = $__default['default'].fn[NAME$9]; - var EVENT_HIDE$3 = "hide" + EVENT_KEY$9; - var EVENT_HIDDEN$3 = "hidden" + EVENT_KEY$9; - var EVENT_SHOW$3 = "show" + EVENT_KEY$9; - var EVENT_SHOWN$3 = "shown" + EVENT_KEY$9; - var EVENT_CLICK_DATA_API$6 = "click" + EVENT_KEY$9 + DATA_API_KEY$7; - var CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu'; - var CLASS_NAME_ACTIVE$3 = 'active'; - var CLASS_NAME_DISABLED$1 = 'disabled'; - var CLASS_NAME_FADE$4 = 'fade'; - var CLASS_NAME_SHOW$6 = 'show'; - var SELECTOR_DROPDOWN$1 = '.dropdown'; - var SELECTOR_NAV_LIST_GROUP$1 = '.nav, .list-group'; - var SELECTOR_ACTIVE$2 = '.active'; - var SELECTOR_ACTIVE_UL = '> li > .active'; - var SELECTOR_DATA_TOGGLE$4 = '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]'; - var SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle'; - var SELECTOR_DROPDOWN_ACTIVE_CHILD = '> .dropdown-menu .active'; + const NAME$1 = 'tab'; + const DATA_KEY$1 = 'bs.tab'; + const EVENT_KEY$1 = `.${DATA_KEY$1}`; + const DATA_API_KEY = '.data-api'; + const EVENT_HIDE$1 = `hide${EVENT_KEY$1}`; + const EVENT_HIDDEN$1 = `hidden${EVENT_KEY$1}`; + const EVENT_SHOW$1 = `show${EVENT_KEY$1}`; + const EVENT_SHOWN$1 = `shown${EVENT_KEY$1}`; + const EVENT_CLICK_DATA_API = `click${EVENT_KEY$1}${DATA_API_KEY}`; + const CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu'; + const CLASS_NAME_ACTIVE = 'active'; + const CLASS_NAME_FADE$1 = 'fade'; + const CLASS_NAME_SHOW$1 = 'show'; + const SELECTOR_DROPDOWN = '.dropdown'; + const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'; + const SELECTOR_ACTIVE = '.active'; + const SELECTOR_ACTIVE_UL = ':scope > li > .active'; + const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]'; + const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'; + const SELECTOR_DROPDOWN_ACTIVE_CHILD = ':scope > .dropdown-menu .active'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ - var Tab = /*#__PURE__*/function () { - function Tab(element) { - this._element = element; - } // Getters - + class Tab extends BaseComponent { + // Getters + static get NAME() { + return NAME$1; + } // Public - var _proto = Tab.prototype; - // Public - _proto.show = function show() { - var _this = this; - - if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $__default['default'](this._element).hasClass(CLASS_NAME_ACTIVE$3) || $__default['default'](this._element).hasClass(CLASS_NAME_DISABLED$1)) { + show() { + if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && this._element.classList.contains(CLASS_NAME_ACTIVE)) { return; } - var target; - var previous; - var listElement = $__default['default'](this._element).closest(SELECTOR_NAV_LIST_GROUP$1)[0]; - var selector = Util.getSelectorFromElement(this._element); + let previous; + const target = getElementFromSelector(this._element); + + const listElement = this._element.closest(SELECTOR_NAV_LIST_GROUP); if (listElement) { - var itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? SELECTOR_ACTIVE_UL : SELECTOR_ACTIVE$2; - previous = $__default['default'].makeArray($__default['default'](listElement).find(itemSelector)); + const itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? SELECTOR_ACTIVE_UL : SELECTOR_ACTIVE; + previous = SelectorEngine.find(itemSelector, listElement); previous = previous[previous.length - 1]; } - var hideEvent = $__default['default'].Event(EVENT_HIDE$3, { + const hideEvent = previous ? EventHandler.trigger(previous, EVENT_HIDE$1, { relatedTarget: this._element - }); - var showEvent = $__default['default'].Event(EVENT_SHOW$3, { + }) : null; + const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$1, { relatedTarget: previous }); - if (previous) { - $__default['default'](previous).trigger(hideEvent); - } - - $__default['default'](this._element).trigger(showEvent); - - if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) { + if (showEvent.defaultPrevented || hideEvent !== null && hideEvent.defaultPrevented) { return; } - if (selector) { - target = document.querySelector(selector); - } - this._activate(this._element, listElement); - var complete = function complete() { - var hiddenEvent = $__default['default'].Event(EVENT_HIDDEN$3, { - relatedTarget: _this._element + const complete = () => { + EventHandler.trigger(previous, EVENT_HIDDEN$1, { + relatedTarget: this._element }); - var shownEvent = $__default['default'].Event(EVENT_SHOWN$3, { + EventHandler.trigger(this._element, EVENT_SHOWN$1, { relatedTarget: previous }); - $__default['default'](previous).trigger(hiddenEvent); - $__default['default'](_this._element).trigger(shownEvent); }; if (target) { @@ -4070,40 +4627,32 @@ } else { complete(); } - }; - - _proto.dispose = function dispose() { - $__default['default'].removeData(this._element, DATA_KEY$9); - this._element = null; } // Private - ; - _proto._activate = function _activate(element, container, callback) { - var _this2 = this; - var activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? $__default['default'](container).find(SELECTOR_ACTIVE_UL) : $__default['default'](container).children(SELECTOR_ACTIVE$2); - var active = activeElements[0]; - var isTransitioning = callback && active && $__default['default'](active).hasClass(CLASS_NAME_FADE$4); + _activate(element, container, callback) { + const activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? SelectorEngine.find(SELECTOR_ACTIVE_UL, container) : SelectorEngine.children(container, SELECTOR_ACTIVE); + const active = activeElements[0]; + const isTransitioning = callback && active && active.classList.contains(CLASS_NAME_FADE$1); - var complete = function complete() { - return _this2._transitionComplete(element, active, callback); - }; + const complete = () => this._transitionComplete(element, active, callback); if (active && isTransitioning) { - var transitionDuration = Util.getTransitionDurationFromElement(active); - $__default['default'](active).removeClass(CLASS_NAME_SHOW$6).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); + active.classList.remove(CLASS_NAME_SHOW$1); + + this._queueCallback(complete, element, true); } else { complete(); } - }; + } - _proto._transitionComplete = function _transitionComplete(element, active, callback) { + _transitionComplete(element, active, callback) { if (active) { - $__default['default'](active).removeClass(CLASS_NAME_ACTIVE$3); - var dropdownChild = $__default['default'](active.parentNode).find(SELECTOR_DROPDOWN_ACTIVE_CHILD)[0]; + active.classList.remove(CLASS_NAME_ACTIVE); + const dropdownChild = SelectorEngine.findOne(SELECTOR_DROPDOWN_ACTIVE_CHILD, active.parentNode); if (dropdownChild) { - $__default['default'](dropdownChild).removeClass(CLASS_NAME_ACTIVE$3); + dropdownChild.classList.remove(CLASS_NAME_ACTIVE); } if (active.getAttribute('role') === 'tab') { @@ -4111,24 +4660,29 @@ } } - $__default['default'](element).addClass(CLASS_NAME_ACTIVE$3); + element.classList.add(CLASS_NAME_ACTIVE); if (element.getAttribute('role') === 'tab') { element.setAttribute('aria-selected', true); } - Util.reflow(element); + reflow(element); - if (element.classList.contains(CLASS_NAME_FADE$4)) { - element.classList.add(CLASS_NAME_SHOW$6); + if (element.classList.contains(CLASS_NAME_FADE$1)) { + element.classList.add(CLASS_NAME_SHOW$1); } - if (element.parentNode && $__default['default'](element.parentNode).hasClass(CLASS_NAME_DROPDOWN_MENU)) { - var dropdownElement = $__default['default'](element).closest(SELECTOR_DROPDOWN$1)[0]; + let parent = element.parentNode; + + if (parent && parent.nodeName === 'LI') { + parent = parent.parentNode; + } + + if (parent && parent.classList.contains(CLASS_NAME_DROPDOWN_MENU)) { + const dropdownElement = element.closest(SELECTOR_DROPDOWN); if (dropdownElement) { - var dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(SELECTOR_DROPDOWN_TOGGLE$1)); - $__default['default'](dropdownToggleList).addClass(CLASS_NAME_ACTIVE$3); + SelectorEngine.find(SELECTOR_DROPDOWN_TOGGLE, dropdownElement).forEach(dropdown => dropdown.classList.add(CLASS_NAME_ACTIVE)); } element.setAttribute('aria-expanded', true); @@ -4138,37 +4692,23 @@ callback(); } } // Static - ; - Tab._jQueryInterface = function _jQueryInterface(config) { - return this.each(function () { - var $this = $__default['default'](this); - var data = $this.data(DATA_KEY$9); - if (!data) { - data = new Tab(this); - $this.data(DATA_KEY$9, data); - } + static jQueryInterface(config) { + return this.each(function () { + const data = Data.get(this, DATA_KEY$1) || new Tab(this); if (typeof config === 'string') { if (typeof data[config] === 'undefined') { - throw new TypeError("No method named \"" + config + "\""); + throw new TypeError(`No method named "${config}"`); } data[config](); } }); - }; - - _createClass(Tab, null, [{ - key: "VERSION", - get: function get() { - return VERSION$9; - } - }]); + } - return Tab; - }(); + } /** * ------------------------------------------------------------------------ * Data Api implementation @@ -4176,257 +4716,280 @@ */ - $__default['default'](document).on(EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$4, function (event) { - event.preventDefault(); + EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { + if (['A', 'AREA'].includes(this.tagName)) { + event.preventDefault(); + } - Tab._jQueryInterface.call($__default['default'](this), 'show'); + if (isDisabled(this)) { + return; + } + + const data = Data.get(this, DATA_KEY$1) || new Tab(this); + data.show(); }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ + * add .Tab to jQuery only if jQuery is present */ - $__default['default'].fn[NAME$9] = Tab._jQueryInterface; - $__default['default'].fn[NAME$9].Constructor = Tab; - - $__default['default'].fn[NAME$9].noConflict = function () { - $__default['default'].fn[NAME$9] = JQUERY_NO_CONFLICT$9; - return Tab._jQueryInterface; - }; + defineJQueryPlugin(Tab); /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): toast.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ - var NAME$a = 'toast'; - var VERSION$a = '4.6.0'; - var DATA_KEY$a = 'bs.toast'; - var EVENT_KEY$a = "." + DATA_KEY$a; - var JQUERY_NO_CONFLICT$a = $__default['default'].fn[NAME$a]; - var EVENT_CLICK_DISMISS$1 = "click.dismiss" + EVENT_KEY$a; - var EVENT_HIDE$4 = "hide" + EVENT_KEY$a; - var EVENT_HIDDEN$4 = "hidden" + EVENT_KEY$a; - var EVENT_SHOW$4 = "show" + EVENT_KEY$a; - var EVENT_SHOWN$4 = "shown" + EVENT_KEY$a; - var CLASS_NAME_FADE$5 = 'fade'; - var CLASS_NAME_HIDE = 'hide'; - var CLASS_NAME_SHOW$7 = 'show'; - var CLASS_NAME_SHOWING = 'showing'; - var DefaultType$7 = { + const NAME = 'toast'; + const DATA_KEY = 'bs.toast'; + const EVENT_KEY = `.${DATA_KEY}`; + const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY}`; + const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`; + const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`; + const EVENT_FOCUSIN = `focusin${EVENT_KEY}`; + const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`; + const EVENT_HIDE = `hide${EVENT_KEY}`; + const EVENT_HIDDEN = `hidden${EVENT_KEY}`; + const EVENT_SHOW = `show${EVENT_KEY}`; + const EVENT_SHOWN = `shown${EVENT_KEY}`; + const CLASS_NAME_FADE = 'fade'; + const CLASS_NAME_HIDE = 'hide'; + const CLASS_NAME_SHOW = 'show'; + const CLASS_NAME_SHOWING = 'showing'; + const DefaultType = { animation: 'boolean', autohide: 'boolean', delay: 'number' }; - var Default$7 = { + const Default = { animation: true, autohide: true, - delay: 500 + delay: 5000 }; - var SELECTOR_DATA_DISMISS$1 = '[data-dismiss="toast"]'; + const SELECTOR_DATA_DISMISS = '[data-bs-dismiss="toast"]'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ - var Toast = /*#__PURE__*/function () { - function Toast(element, config) { - this._element = element; + class Toast extends BaseComponent { + constructor(element, config) { + super(element); this._config = this._getConfig(config); this._timeout = null; + this._hasMouseInteraction = false; + this._hasKeyboardInteraction = false; this._setListeners(); } // Getters - var _proto = Toast.prototype; + static get DefaultType() { + return DefaultType; + } + + static get Default() { + return Default; + } + + static get NAME() { + return NAME; + } // Public - // Public - _proto.show = function show() { - var _this = this; - var showEvent = $__default['default'].Event(EVENT_SHOW$4); - $__default['default'](this._element).trigger(showEvent); + show() { + const showEvent = EventHandler.trigger(this._element, EVENT_SHOW); - if (showEvent.isDefaultPrevented()) { + if (showEvent.defaultPrevented) { return; } this._clearTimeout(); if (this._config.animation) { - this._element.classList.add(CLASS_NAME_FADE$5); + this._element.classList.add(CLASS_NAME_FADE); } - var complete = function complete() { - _this._element.classList.remove(CLASS_NAME_SHOWING); + const complete = () => { + this._element.classList.remove(CLASS_NAME_SHOWING); - _this._element.classList.add(CLASS_NAME_SHOW$7); + this._element.classList.add(CLASS_NAME_SHOW); - $__default['default'](_this._element).trigger(EVENT_SHOWN$4); + EventHandler.trigger(this._element, EVENT_SHOWN); - if (_this._config.autohide) { - _this._timeout = setTimeout(function () { - _this.hide(); - }, _this._config.delay); - } + this._maybeScheduleHide(); }; this._element.classList.remove(CLASS_NAME_HIDE); - Util.reflow(this._element); + reflow(this._element); this._element.classList.add(CLASS_NAME_SHOWING); - if (this._config.animation) { - var transitionDuration = Util.getTransitionDurationFromElement(this._element); - $__default['default'](this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); - } else { - complete(); - } - }; + this._queueCallback(complete, this._element, this._config.animation); + } - _proto.hide = function hide() { - if (!this._element.classList.contains(CLASS_NAME_SHOW$7)) { + hide() { + if (!this._element.classList.contains(CLASS_NAME_SHOW)) { return; } - var hideEvent = $__default['default'].Event(EVENT_HIDE$4); - $__default['default'](this._element).trigger(hideEvent); + const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE); - if (hideEvent.isDefaultPrevented()) { + if (hideEvent.defaultPrevented) { return; } - this._close(); - }; + const complete = () => { + this._element.classList.add(CLASS_NAME_HIDE); + + EventHandler.trigger(this._element, EVENT_HIDDEN); + }; + + this._element.classList.remove(CLASS_NAME_SHOW); - _proto.dispose = function dispose() { + this._queueCallback(complete, this._element, this._config.animation); + } + + dispose() { this._clearTimeout(); - if (this._element.classList.contains(CLASS_NAME_SHOW$7)) { - this._element.classList.remove(CLASS_NAME_SHOW$7); + if (this._element.classList.contains(CLASS_NAME_SHOW)) { + this._element.classList.remove(CLASS_NAME_SHOW); } - $__default['default'](this._element).off(EVENT_CLICK_DISMISS$1); - $__default['default'].removeData(this._element, DATA_KEY$a); - this._element = null; - this._config = null; + super.dispose(); } // Private - ; - _proto._getConfig = function _getConfig(config) { - config = _extends({}, Default$7, $__default['default'](this._element).data(), typeof config === 'object' && config ? config : {}); - Util.typeCheckConfig(NAME$a, config, this.constructor.DefaultType); + + _getConfig(config) { + config = { ...Default, + ...Manipulator.getDataAttributes(this._element), + ...(typeof config === 'object' && config ? config : {}) + }; + typeCheckConfig(NAME, config, this.constructor.DefaultType); return config; - }; + } - _proto._setListeners = function _setListeners() { - var _this2 = this; + _maybeScheduleHide() { + if (!this._config.autohide) { + return; + } - $__default['default'](this._element).on(EVENT_CLICK_DISMISS$1, SELECTOR_DATA_DISMISS$1, function () { - return _this2.hide(); - }); - }; + if (this._hasMouseInteraction || this._hasKeyboardInteraction) { + return; + } - _proto._close = function _close() { - var _this3 = this; + this._timeout = setTimeout(() => { + this.hide(); + }, this._config.delay); + } - var complete = function complete() { - _this3._element.classList.add(CLASS_NAME_HIDE); + _onInteraction(event, isInteracting) { + switch (event.type) { + case 'mouseover': + case 'mouseout': + this._hasMouseInteraction = isInteracting; + break; - $__default['default'](_this3._element).trigger(EVENT_HIDDEN$4); - }; + case 'focusin': + case 'focusout': + this._hasKeyboardInteraction = isInteracting; + break; + } - this._element.classList.remove(CLASS_NAME_SHOW$7); + if (isInteracting) { + this._clearTimeout(); - if (this._config.animation) { - var transitionDuration = Util.getTransitionDurationFromElement(this._element); - $__default['default'](this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); - } else { - complete(); + return; } - }; - _proto._clearTimeout = function _clearTimeout() { + const nextElement = event.relatedTarget; + + if (this._element === nextElement || this._element.contains(nextElement)) { + return; + } + + this._maybeScheduleHide(); + } + + _setListeners() { + EventHandler.on(this._element, EVENT_CLICK_DISMISS, SELECTOR_DATA_DISMISS, () => this.hide()); + EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true)); + EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false)); + EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true)); + EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false)); + } + + _clearTimeout() { clearTimeout(this._timeout); this._timeout = null; } // Static - ; - Toast._jQueryInterface = function _jQueryInterface(config) { + + static jQueryInterface(config) { return this.each(function () { - var $element = $__default['default'](this); - var data = $element.data(DATA_KEY$a); + let data = Data.get(this, DATA_KEY); - var _config = typeof config === 'object' && config; + const _config = typeof config === 'object' && config; if (!data) { data = new Toast(this, _config); - $element.data(DATA_KEY$a, data); } if (typeof config === 'string') { if (typeof data[config] === 'undefined') { - throw new TypeError("No method named \"" + config + "\""); + throw new TypeError(`No method named "${config}"`); } data[config](this); } }); - }; - - _createClass(Toast, null, [{ - key: "VERSION", - get: function get() { - return VERSION$a; - } - }, { - key: "DefaultType", - get: function get() { - return DefaultType$7; - } - }, { - key: "Default", - get: function get() { - return Default$7; - } - }]); + } - return Toast; - }(); + } /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ + * add .Toast to jQuery only if jQuery is present */ - $__default['default'].fn[NAME$a] = Toast._jQueryInterface; - $__default['default'].fn[NAME$a].Constructor = Toast; + defineJQueryPlugin(Toast); - $__default['default'].fn[NAME$a].noConflict = function () { - $__default['default'].fn[NAME$a] = JQUERY_NO_CONFLICT$a; - return Toast._jQueryInterface; + /** + * -------------------------------------------------------------------------- + * Bootstrap (v5.0.1): index.umd.js + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + * -------------------------------------------------------------------------- + */ + var index_umd = { + Alert, + Button, + Carousel, + Collapse, + Dropdown, + Modal, + Offcanvas, + Popover, + ScrollSpy, + Tab, + Toast, + Tooltip }; - exports.Alert = Alert; - exports.Button = Button; - exports.Carousel = Carousel; - exports.Collapse = Collapse; - exports.Dropdown = Dropdown; - exports.Modal = Modal; - exports.Popover = Popover; - exports.Scrollspy = ScrollSpy; - exports.Tab = Tab; - exports.Toast = Toast; - exports.Tooltip = Tooltip; - exports.Util = Util; - - Object.defineProperty(exports, '__esModule', { value: true }); + return index_umd; }))); //# sourceMappingURL=bootstrap.js.map |