/*! * Bootstrap v5.0.0-beta2 (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' ? 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); } var Popper__namespace = /*#__PURE__*/_interopNamespace(Popper); 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); } } function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; } /** * -------------------------------------------------------------------------- * Bootstrap (v5.0.0-beta2): util/index.js * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) * -------------------------------------------------------------------------- */ var MAX_UID = 1000000; var MILLISECONDS_MULTIPLIER = 1000; var TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp) var toType = function toType(obj) { if (obj === null || obj === undefined) { return "" + obj; } return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); }; /** * -------------------------------------------------------------------------- * Public Util Api * -------------------------------------------------------------------------- */ var getUID = function getUID(prefix) { do { prefix += Math.floor(Math.random() * MAX_UID); } while (document.getElementById(prefix)); return prefix; }; var getSelector = function getSelector(element) { var selector = element.getAttribute('data-bs-target'); if (!selector || selector === '#') { var 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]; } selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null; } return selector; }; var getSelectorFromElement = function getSelectorFromElement(element) { var selector = getSelector(element); if (selector) { return document.querySelector(selector) ? selector : null; } return null; }; var getElementFromSelector = function getElementFromSelector(element) { var selector = getSelector(element); return selector ? document.querySelector(selector) : null; }; var getTransitionDurationFromElement = function getTransitionDurationFromElement(element) { if (!element) { return 0; } // Get transition-duration of the element var _window$getComputedSt = window.getComputedStyle(element), transitionDuration = _window$getComputedSt.transitionDuration, transitionDelay = _window$getComputedSt.transitionDelay; var floatTransitionDuration = Number.parseFloat(transitionDuration); var 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; }; var triggerTransitionEnd = function triggerTransitionEnd(element) { element.dispatchEvent(new Event(TRANSITION_END)); }; var isElement = function isElement(obj) { return (obj[0] || obj).nodeType; }; var emulateTransitionEnd = function emulateTransitionEnd(element, duration) { var called = false; var durationPadding = 5; var emulatedDuration = duration + durationPadding; function listener() { called = true; element.removeEventListener(TRANSITION_END, listener); } element.addEventListener(TRANSITION_END, listener); setTimeout(function () { if (!called) { triggerTransitionEnd(element); } }, emulatedDuration); }; var typeCheckConfig = function typeCheckConfig(componentName, config, configTypes) { Object.keys(configTypes).forEach(function (property) { var expectedTypes = configTypes[property]; var value = config[property]; var 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 + "\".")); } }); }; var isVisible = function isVisible(element) { if (!element) { return false; } if (element.style && element.parentNode && element.parentNode.style) { var elementStyle = getComputedStyle(element); var parentNodeStyle = getComputedStyle(element.parentNode); return elementStyle.display !== 'none' && parentNodeStyle.display !== 'none' && elementStyle.visibility !== 'hidden'; } return false; }; var findShadowRoot = function findShadowRoot(element) { if (!document.documentElement.attachShadow) { return null; } // Can find the shadow root otherwise it'll return the document if (typeof element.getRootNode === 'function') { var 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); }; var noop = function noop() { return function () {}; }; var reflow = function reflow(element) { return element.offsetHeight; }; var getjQuery = function getjQuery() { var _window = window, jQuery = _window.jQuery; if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { return jQuery; } return null; }; var onDOMContentLoaded = function onDOMContentLoaded(callback) { if (document.readyState === 'loading') { document.addEventListener('DOMContentLoaded', callback); } else { callback(); } }; var isRTL = document.documentElement.dir === 'rtl'; var defineJQueryPlugin = function defineJQueryPlugin(name, plugin) { onDOMContentLoaded(function () { var $ = getjQuery(); /* istanbul ignore if */ if ($) { var JQUERY_NO_CONFLICT = $.fn[name]; $.fn[name] = plugin.jQueryInterface; $.fn[name].Constructor = plugin; $.fn[name].noConflict = function () { $.fn[name] = JQUERY_NO_CONFLICT; return plugin.jQueryInterface; }; } }); }; /** * -------------------------------------------------------------------------- * Bootstrap (v5.0.0-beta2): dom/data.js * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) * -------------------------------------------------------------------------- */ /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var mapData = function () { var storeData = {}; var id = 1; return { set: function set(element, key, data) { if (typeof element.bsKey === 'undefined') { element.bsKey = { key: key, id: id }; id++; } storeData[element.bsKey.id] = data; }, get: function get(element, key) { if (!element || typeof element.bsKey === 'undefined') { return null; } var keyProperties = element.bsKey; if (keyProperties.key === key) { return storeData[keyProperties.id]; } return null; }, delete: function _delete(element, key) { if (typeof element.bsKey === 'undefined') { return; } var keyProperties = element.bsKey; if (keyProperties.key === key) { delete storeData[keyProperties.id]; delete element.bsKey; } } }; }(); var Data = { setData: function setData(instance, key, data) { mapData.set(instance, key, data); }, getData: function getData(instance, key) { return mapData.get(instance, key); }, removeData: function removeData(instance, key) { mapData.delete(instance, key); } }; /** * -------------------------------------------------------------------------- * Bootstrap (v5.0.0-beta2): dom/event-handler.js * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) * -------------------------------------------------------------------------- */ /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var namespaceRegex = /[^.]*(?=\..*)\.|.*/; var stripNameRegex = /\..*/; var stripUidRegex = /::\d+$/; var eventRegistry = {}; // Events storage var uidEvent = 1; var customEvents = { mouseenter: 'mouseover', mouseleave: 'mouseout' }; var 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) { var 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) { var domElements = element.querySelectorAll(selector); for (var target = event.target; target && target !== this; target = target.parentNode) { for (var 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, fn); } return fn.apply(target, [event]); } } } // To please ESLint return null; }; } function findHandler(events, handler, delegationSelector) { if (delegationSelector === void 0) { delegationSelector = null; } var uidEventList = Object.keys(events); for (var i = 0, len = uidEventList.length; i < len; i++) { var event = events[uidEventList[i]]; if (event.originalHandler === handler && event.delegationSelector === delegationSelector) { return event; } } return null; } function normalizeParams(originalTypeEvent, handler, delegationFn) { var delegation = typeof handler === 'string'; var originalHandler = delegation ? delegationFn : handler; // allow to get the native events from namespaced events ('click.bs.button' --> 'click') var typeEvent = originalTypeEvent.replace(stripNameRegex, ''); var custom = customEvents[typeEvent]; if (custom) { typeEvent = custom; } var 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; } var _normalizeParams = normalizeParams(originalTypeEvent, handler, delegationFn), delegation = _normalizeParams[0], originalHandler = _normalizeParams[1], typeEvent = _normalizeParams[2]; var events = getEvent(element); var handlers = events[typeEvent] || (events[typeEvent] = {}); var previousFn = findHandler(handlers, originalHandler, delegation ? handler : null); if (previousFn) { previousFn.oneOff = previousFn.oneOff && oneOff; return; } var uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, '')); var 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) { var 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) { var storeElementEvent = events[typeEvent] || {}; Object.keys(storeElementEvent).forEach(function (handlerKey) { if (handlerKey.includes(namespace)) { var event = storeElementEvent[handlerKey]; removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector); } }); } var EventHandler = { on: function on(element, event, handler, delegationFn) { addHandler(element, event, handler, delegationFn, false); }, one: function one(element, event, handler, delegationFn) { addHandler(element, event, handler, delegationFn, true); }, off: function off(element, originalTypeEvent, handler, delegationFn) { if (typeof originalTypeEvent !== 'string' || !element) { return; } var _normalizeParams2 = normalizeParams(originalTypeEvent, handler, delegationFn), delegation = _normalizeParams2[0], originalHandler = _normalizeParams2[1], typeEvent = _normalizeParams2[2]; var inNamespace = typeEvent !== originalTypeEvent; var events = getEvent(element); var 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(function (elementEvent) { removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1)); }); } var storeElementEvent = events[typeEvent] || {}; Object.keys(storeElementEvent).forEach(function (keyHandlers) { var handlerKey = keyHandlers.replace(stripUidRegex, ''); if (!inNamespace || originalTypeEvent.includes(handlerKey)) { var event = storeElementEvent[keyHandlers]; removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector); } }); }, trigger: function trigger(element, event, args) { if (typeof event !== 'string' || !element) { return null; } var $ = getjQuery(); var typeEvent = event.replace(stripNameRegex, ''); var inNamespace = event !== typeEvent; var isNative = nativeEvents.has(typeEvent); var jQueryEvent; var bubbles = true; var nativeDispatch = true; var defaultPrevented = false; var evt = null; if (inNamespace && $) { jQueryEvent = $.Event(event, args); $(element).trigger(jQueryEvent); bubbles = !jQueryEvent.isPropagationStopped(); nativeDispatch = !jQueryEvent.isImmediatePropagationStopped(); defaultPrevented = jQueryEvent.isDefaultPrevented(); } if (isNative) { evt = document.createEvent('HTMLEvents'); evt.initEvent(typeEvent, bubbles, true); } else { evt = new CustomEvent(event, { bubbles: bubbles, cancelable: true }); } // merge custom information in our event if (typeof args !== 'undefined') { Object.keys(args).forEach(function (key) { Object.defineProperty(evt, key, { get: function get() { return args[key]; } }); }); } if (defaultPrevented) { evt.preventDefault(); } if (nativeDispatch) { element.dispatchEvent(evt); } if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') { jQueryEvent.preventDefault(); } return evt; } }; /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var VERSION = '5.0.0-beta2'; var BaseComponent = /*#__PURE__*/function () { function BaseComponent(element) { if (!element) { return; } this._element = element; Data.setData(element, this.constructor.DATA_KEY, this); } var _proto = BaseComponent.prototype; _proto.dispose = function dispose() { Data.removeData(this._element, this.constructor.DATA_KEY); this._element = null; } /** Static */ ; BaseComponent.getInstance = function getInstance(element) { return Data.getData(element, this.DATA_KEY); }; _createClass(BaseComponent, null, [{ key: "VERSION", get: function get() { return VERSION; } }]); return BaseComponent; }(); /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var NAME = 'alert'; var DATA_KEY = 'bs.alert'; var EVENT_KEY = "." + DATA_KEY; var DATA_API_KEY = '.data-api'; var SELECTOR_DISMISS = '[data-bs-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 * ------------------------------------------------------------------------ */ var Alert = /*#__PURE__*/function (_BaseComponent) { _inheritsLoose(Alert, _BaseComponent); function Alert() { return _BaseComponent.apply(this, arguments) || this; } var _proto = Alert.prototype; // Public _proto.close = function close(element) { var rootElement = element ? this._getRootElement(element) : this._element; var customEvent = this._triggerCloseEvent(rootElement); if (customEvent === null || customEvent.defaultPrevented) { return; } this._removeElement(rootElement); } // Private ; _proto._getRootElement = function _getRootElement(element) { return getElementFromSelector(element) || element.closest("." + CLASS_NAME_ALERT); }; _proto._triggerCloseEvent = function _triggerCloseEvent(element) { return EventHandler.trigger(element, EVENT_CLOSE); }; _proto._removeElement = function _removeElement(element) { var _this = this; element.classList.remove(CLASS_NAME_SHOW); if (!element.classList.contains(CLASS_NAME_FADE)) { this._destroyElement(element); return; } var transitionDuration = getTransitionDurationFromElement(element); EventHandler.one(element, 'transitionend', function () { return _this._destroyElement(element); }); emulateTransitionEnd(element, transitionDuration); }; _proto._destroyElement = function _destroyElement(element) { if (element.parentNode) { element.parentNode.removeChild(element); } EventHandler.trigger(element, EVENT_CLOSED); } // Static ; Alert.jQueryInterface = function jQueryInterface(config) { return this.each(function () { var data = Data.getData(this, DATA_KEY); if (!data) { data = new Alert(this); } if (config === 'close') { data[config](this); } }); }; Alert.handleDismiss = function handleDismiss(alertInstance) { return function (event) { if (event) { event.preventDefault(); } alertInstance.close(this); }; }; _createClass(Alert, null, [{ key: "DATA_KEY", // Getters get: function get() { return DATA_KEY; } }]); return Alert; }(BaseComponent); /** * ------------------------------------------------------------------------ * Data Api implementation * ------------------------------------------------------------------------ */ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DISMISS, Alert.handleDismiss(new Alert())); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ * add .Alert to jQuery only if jQuery is present */ defineJQueryPlugin(NAME, Alert); /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var NAME$1 = 'button'; var DATA_KEY$1 = 'bs.button'; var EVENT_KEY$1 = "." + DATA_KEY$1; var DATA_API_KEY$1 = '.data-api'; var CLASS_NAME_ACTIVE = 'active'; var SELECTOR_DATA_TOGGLE = '[data-bs-toggle="button"]'; var EVENT_CLICK_DATA_API$1 = "click" + EVENT_KEY$1 + DATA_API_KEY$1; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ var Button = /*#__PURE__*/function (_BaseComponent) { _inheritsLoose(Button, _BaseComponent); function Button() { return _BaseComponent.apply(this, arguments) || this; } var _proto = Button.prototype; // Public _proto.toggle = function 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)); } // Static ; Button.jQueryInterface = function jQueryInterface(config) { return this.each(function () { var data = Data.getData(this, DATA_KEY$1); if (!data) { data = new Button(this); } if (config === 'toggle') { data[config](); } }); }; _createClass(Button, null, [{ key: "DATA_KEY", // Getters get: function get() { return DATA_KEY$1; } }]); return Button; }(BaseComponent); /** * ------------------------------------------------------------------------ * Data Api implementation * ------------------------------------------------------------------------ */ EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE, function (event) { event.preventDefault(); var button = event.target.closest(SELECTOR_DATA_TOGGLE); var data = Data.getData(button, DATA_KEY$1); if (!data) { data = new Button(button); } data.toggle(); }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ * add .Button to jQuery only if jQuery is present */ defineJQueryPlugin(NAME$1, Button); /** * -------------------------------------------------------------------------- * Bootstrap (v5.0.0-beta2): dom/manipulator.js * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) * -------------------------------------------------------------------------- */ function normalizeData(val) { if (val === 'true') { return true; } if (val === 'false') { return false; } if (val === Number(val).toString()) { return Number(val); } if (val === '' || val === 'null') { return null; } return val; } function normalizeDataKey(key) { return key.replace(/[A-Z]/g, function (chr) { return "-" + chr.toLowerCase(); }); } var Manipulator = { setDataAttribute: function setDataAttribute(element, key, value) { element.setAttribute("data-bs-" + normalizeDataKey(key), value); }, removeDataAttribute: function removeDataAttribute(element, key) { element.removeAttribute("data-bs-" + normalizeDataKey(key)); }, getDataAttributes: function getDataAttributes(element) { if (!element) { return {}; } var attributes = {}; Object.keys(element.dataset).filter(function (key) { return key.startsWith('bs'); }).forEach(function (key) { var pureKey = key.replace(/^bs/, ''); pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length); attributes[pureKey] = normalizeData(element.dataset[key]); }); return attributes; }, getDataAttribute: function getDataAttribute(element, key) { return normalizeData(element.getAttribute("data-bs-" + normalizeDataKey(key))); }, offset: function offset(element) { var rect = element.getBoundingClientRect(); return { top: rect.top + document.body.scrollTop, left: rect.left + document.body.scrollLeft }; }, position: function position(element) { return { top: element.offsetTop, left: element.offsetLeft }; } }; /** * -------------------------------------------------------------------------- * Bootstrap (v5.0.0-beta2): dom/selector-engine.js * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) * -------------------------------------------------------------------------- */ /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var NODE_TEXT = 3; var SelectorEngine = { find: function find(selector, element) { var _ref; if (element === void 0) { element = document.documentElement; } return (_ref = []).concat.apply(_ref, Element.prototype.querySelectorAll.call(element, selector)); }, findOne: function findOne(selector, element) { if (element === void 0) { element = document.documentElement; } return Element.prototype.querySelector.call(element, selector); }, children: function children(element, selector) { var _ref2; return (_ref2 = []).concat.apply(_ref2, element.children).filter(function (child) { return child.matches(selector); }); }, parents: function parents(element, selector) { var parents = []; var 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 parents; }, prev: function prev(element, selector) { var previous = element.previousElementSibling; while (previous) { if (previous.matches(selector)) { return [previous]; } previous = previous.previousElementSibling; } return []; }, next: function next(element, selector) { var next = element.nextElementSibling; while (next) { if (next.matches(selector)) { return [next]; } next = next.nextElementSibling; } return []; } }; /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var NAME$2 = 'carousel'; var DATA_KEY$2 = 'bs.carousel'; var EVENT_KEY$2 = "." + DATA_KEY$2; var DATA_API_KEY$2 = '.data-api'; var ARROW_LEFT_KEY = 'ArrowLeft'; var ARROW_RIGHT_KEY = 'ArrowRight'; var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch var SWIPE_THRESHOLD = 40; var Default = { interval: 5000, keyboard: true, slide: false, pause: 'hover', wrap: true, touch: true }; var DefaultType = { interval: '(number|boolean)', keyboard: 'boolean', slide: '(boolean|string)', pause: '(string|boolean)', 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 = "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_END = 'carousel-item-end'; var CLASS_NAME_START = 'carousel-item-start'; var CLASS_NAME_NEXT = 'carousel-item-next'; var CLASS_NAME_PREV = 'carousel-item-prev'; var CLASS_NAME_POINTER_EVENT = 'pointer-event'; var SELECTOR_ACTIVE = '.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_INDICATOR = '[data-bs-target]'; var SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]'; var SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]'; var POINTER_TYPE_TOUCH = 'touch'; var POINTER_TYPE_PEN = 'pen'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ var Carousel = /*#__PURE__*/function (_BaseComponent) { _inheritsLoose(Carousel, _BaseComponent); function Carousel(element, config) { var _this; _this = _BaseComponent.call(this, element) || this; _this._items = null; _this._interval = null; _this._activeElement = null; _this._isPaused = false; _this._isSliding = false; _this.touchTimeout = null; _this.touchStartX = 0; _this.touchDeltaX = 0; _this._config = _this._getConfig(config); _this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, _this._element); _this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0; _this._pointerEvent = Boolean(window.PointerEvent); _this._addEventListeners(); return _this; } // Getters var _proto = Carousel.prototype; // Public _proto.next = function next() { if (!this._isSliding) { this._slide(DIRECTION_NEXT); } }; _proto.nextWhenVisible = function nextWhenVisible() { // Don't call next when the page isn't visible // or the carousel or its parent isn't visible if (!document.hidden && isVisible(this._element)) { this.next(); } }; _proto.prev = function prev() { if (!this._isSliding) { this._slide(DIRECTION_PREV); } }; _proto.pause = function pause(event) { if (!event) { this._isPaused = true; } 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) { if (!event) { this._isPaused = false; } if (this._interval) { clearInterval(this._interval); this._interval = null; } 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 _this2 = this; this._activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element); var activeIndex = this._getItemIndex(this._activeElement); if (index > this._items.length - 1 || index < 0) { return; } if (this._isSliding) { EventHandler.one(this._element, EVENT_SLID, function () { return _this2.to(index); }); return; } if (activeIndex === index) { this.pause(); this.cycle(); return; } var direction = index > activeIndex ? DIRECTION_NEXT : DIRECTION_PREV; this._slide(direction, this._items[index]); }; _proto.dispose = function dispose() { _BaseComponent.prototype.dispose.call(this); EventHandler.off(this._element, EVENT_KEY$2); this._items = null; this._config = null; this._interval = null; this._isPaused = null; this._isSliding = null; this._activeElement = null; this._indicatorsElement = null; } // Private ; _proto._getConfig = function _getConfig(config) { config = _extends({}, Default, config); typeCheckConfig(NAME$2, config, DefaultType); return config; }; _proto._handleSwipe = function _handleSwipe() { var absDeltax = Math.abs(this.touchDeltaX); if (absDeltax <= SWIPE_THRESHOLD) { return; } var direction = absDeltax / this.touchDeltaX; this.touchDeltaX = 0; // swipe left if (direction > 0) { if (isRTL) { this.next(); } else { this.prev(); } } // swipe right if (direction < 0) { if (isRTL) { this.prev(); } else { this.next(); } } }; _proto._addEventListeners = function _addEventListeners() { var _this3 = this; if (this._config.keyboard) { EventHandler.on(this._element, EVENT_KEYDOWN, function (event) { return _this3._keydown(event); }); } if (this._config.pause === 'hover') { EventHandler.on(this._element, EVENT_MOUSEENTER, function (event) { return _this3.pause(event); }); EventHandler.on(this._element, EVENT_MOUSELEAVE, function (event) { return _this3.cycle(event); }); } if (this._config.touch && this._touchSupported) { this._addTouchEventListeners(); } }; _proto._addTouchEventListeners = function _addTouchEventListeners() { var _this4 = this; var start = function start(event) { if (_this4._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) { _this4.touchStartX = event.clientX; } else if (!_this4._pointerEvent) { _this4.touchStartX = event.touches[0].clientX; } }; var move = function move(event) { // ensure swiping with one touch and not pinching if (event.touches && event.touches.length > 1) { _this4.touchDeltaX = 0; } else { _this4.touchDeltaX = event.touches[0].clientX - _this4.touchStartX; } }; var end = function end(event) { if (_this4._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) { _this4.touchDeltaX = event.clientX - _this4.touchStartX; } _this4._handleSwipe(); if (_this4._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; // here, we listen for touchend, explicitly pause the carousel // (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 _this4.pause(); if (_this4.touchTimeout) { clearTimeout(_this4.touchTimeout); } _this4.touchTimeout = setTimeout(function (event) { return _this4.cycle(event); }, TOUCHEVENT_COMPAT_WAIT + _this4._config.interval); } }; SelectorEngine.find(SELECTOR_ITEM_IMG, this._element).forEach(function (itemImg) { EventHandler.on(itemImg, EVENT_DRAG_START, function (e) { return e.preventDefault(); }); }); if (this._pointerEvent) { EventHandler.on(this._element, EVENT_POINTERDOWN, function (event) { return start(event); }); EventHandler.on(this._element, EVENT_POINTERUP, function (event) { return end(event); }); this._element.classList.add(CLASS_NAME_POINTER_EVENT); } else { EventHandler.on(this._element, EVENT_TOUCHSTART, function (event) { return start(event); }); EventHandler.on(this._element, EVENT_TOUCHMOVE, function (event) { return move(event); }); EventHandler.on(this._element, EVENT_TOUCHEND, function (event) { return end(event); }); } }; _proto._keydown = function _keydown(event) { if (/input|textarea/i.test(event.target.tagName)) { return; } if (event.key === ARROW_LEFT_KEY) { event.preventDefault(); if (isRTL) { this.next(); } else { this.prev(); } } else if (event.key === ARROW_RIGHT_KEY) { event.preventDefault(); if (isRTL) { this.prev(); } else { this.next(); } } }; _proto._getItemIndex = function _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; var activeIndex = this._getItemIndex(activeElement); var lastItemIndex = this._items.length - 1; var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex; if (isGoingToWrap && !this._config.wrap) { return activeElement; } var delta = direction === DIRECTION_PREV ? -1 : 1; var 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); var fromIndex = this._getItemIndex(SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element)); return EventHandler.trigger(this._element, EVENT_SLIDE, { relatedTarget: relatedTarget, direction: eventDirectionName, from: fromIndex, to: targetIndex }); }; _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) { if (this._indicatorsElement) { var activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement); activeIndicator.classList.remove(CLASS_NAME_ACTIVE$1); activeIndicator.removeAttribute('aria-current'); var indicators = SelectorEngine.find(SELECTOR_INDICATOR, this._indicatorsElement); for (var 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$1); indicators[i].setAttribute('aria-current', 'true'); break; } } } }; _proto._updateInterval = function _updateInterval() { var element = this._activeElement || SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element); if (!element) { return; } var elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10); if (elementInterval) { this._config.defaultInterval = this._config.defaultInterval || this._config.interval; this._config.interval = elementInterval; } else { this._config.interval = this._config.defaultInterval || this._config.interval; } }; _proto._slide = function _slide(direction, element) { var _this5 = this; var activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element); var activeElementIndex = this._getItemIndex(activeElement); var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement); var nextElementIndex = this._getItemIndex(nextElement); var isCycling = Boolean(this._interval); var directionalClassName = direction === DIRECTION_NEXT ? CLASS_NAME_START : CLASS_NAME_END; var orderClassName = direction === DIRECTION_NEXT ? CLASS_NAME_NEXT : CLASS_NAME_PREV; var eventDirectionName = direction === DIRECTION_NEXT ? DIRECTION_LEFT : DIRECTION_RIGHT; if (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE$1)) { this._isSliding = false; return; } var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName); if (slideEvent.defaultPrevented) { return; } if (!activeElement || !nextElement) { // Some weirdness is happening, so we bail return; } this._isSliding = true; if (isCycling) { this.pause(); } this._setActiveIndicatorElement(nextElement); this._activeElement = nextElement; if (this._element.classList.contains(CLASS_NAME_SLIDE)) { nextElement.classList.add(orderClassName); reflow(nextElement); activeElement.classList.add(directionalClassName); nextElement.classList.add(directionalClassName); var transitionDuration = getTransitionDurationFromElement(activeElement); EventHandler.one(activeElement, 'transitionend', function () { nextElement.classList.remove(directionalClassName, orderClassName); nextElement.classList.add(CLASS_NAME_ACTIVE$1); activeElement.classList.remove(CLASS_NAME_ACTIVE$1, orderClassName, directionalClassName); _this5._isSliding = false; setTimeout(function () { EventHandler.trigger(_this5._element, EVENT_SLID, { relatedTarget: nextElement, direction: eventDirectionName, from: activeElementIndex, to: nextElementIndex }); }, 0); }); emulateTransitionEnd(activeElement, transitionDuration); } else { activeElement.classList.remove(CLASS_NAME_ACTIVE$1); nextElement.classList.add(CLASS_NAME_ACTIVE$1); this._isSliding = false; EventHandler.trigger(this._element, EVENT_SLID, { relatedTarget: nextElement, direction: eventDirectionName, from: activeElementIndex, to: nextElementIndex }); } if (isCycling) { this.cycle(); } } // Static ; Carousel.carouselInterface = function carouselInterface(element, config) { var data = Data.getData(element, DATA_KEY$2); var _config = _extends({}, Default, Manipulator.getDataAttributes(element)); if (typeof config === 'object') { _config = _extends({}, _config, config); } var action = typeof config === 'string' ? config : _config.slide; if (!data) { data = new Carousel(element, _config); } 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(); } }; Carousel.jQueryInterface = function jQueryInterface(config) { return this.each(function () { Carousel.carouselInterface(this, config); }); }; Carousel.dataApiClickHandler = function dataApiClickHandler(event) { var target = getElementFromSelector(this); if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) { return; } var config = _extends({}, Manipulator.getDataAttributes(target), Manipulator.getDataAttributes(this)); var slideIndex = this.getAttribute('data-bs-slide-to'); if (slideIndex) { config.interval = false; } Carousel.carouselInterface(target, config); if (slideIndex) { Data.getData(target, DATA_KEY$2).to(slideIndex); } event.preventDefault(); }; _createClass(Carousel, null, [{ key: "Default", get: function get() { return Default; } }, { key: "DATA_KEY", get: function get() { return DATA_KEY$2; } }]); return Carousel; }(BaseComponent); /** * ------------------------------------------------------------------------ * Data Api implementation * ------------------------------------------------------------------------ */ EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_SLIDE, Carousel.dataApiClickHandler); EventHandler.on(window, EVENT_LOAD_DATA_API, function () { var carousels = SelectorEngine.find(SELECTOR_DATA_RIDE); for (var i = 0, len = carousels.length; i < len; i++) { Carousel.carouselInterface(carousels[i], Data.getData(carousels[i], DATA_KEY$2)); } }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ * add .Carousel to jQuery only if jQuery is present */ defineJQueryPlugin(NAME$2, Carousel); /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var NAME$3 = 'collapse'; var DATA_KEY$3 = 'bs.collapse'; var EVENT_KEY$3 = "." + DATA_KEY$3; var DATA_API_KEY$3 = '.data-api'; var Default$1 = { toggle: true, parent: '' }; var DefaultType$1 = { 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 WIDTH = 'width'; var HEIGHT = 'height'; var SELECTOR_ACTIVES = '.show, .collapsing'; var SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="collapse"]'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ var Collapse = /*#__PURE__*/function (_BaseComponent) { _inheritsLoose(Collapse, _BaseComponent); function Collapse(element, config) { var _this; _this = _BaseComponent.call(this, element) || this; _this._isTransitioning = false; _this._config = _this._getConfig(config); _this._triggerArray = SelectorEngine.find(SELECTOR_DATA_TOGGLE$1 + "[href=\"#" + element.id + "\"]," + (SELECTOR_DATA_TOGGLE$1 + "[data-bs-target=\"#" + element.id + "\"]")); var toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$1); for (var i = 0, len = toggleList.length; i < len; i++) { var elem = toggleList[i]; var selector = getSelectorFromElement(elem); var filterElement = SelectorEngine.find(selector).filter(function (foundElem) { return foundElem === element; }); if (selector !== null && filterElement.length) { _this._selector = selector; _this._triggerArray.push(elem); } } _this._parent = _this._config.parent ? _this._getParent() : null; if (!_this._config.parent) { _this._addAriaAndCollapsedClass(_this._element, _this._triggerArray); } if (_this._config.toggle) { _this.toggle(); } return _this; } // Getters var _proto = Collapse.prototype; // Public _proto.toggle = function toggle() { if (this._element.classList.contains(CLASS_NAME_SHOW$1)) { this.hide(); } else { this.show(); } }; _proto.show = function show() { var _this2 = this; if (this._isTransitioning || this._element.classList.contains(CLASS_NAME_SHOW$1)) { return; } var actives; var activesData; if (this._parent) { actives = SelectorEngine.find(SELECTOR_ACTIVES, this._parent).filter(function (elem) { if (typeof _this2._config.parent === 'string') { return elem.getAttribute('data-bs-parent') === _this2._config.parent; } return elem.classList.contains(CLASS_NAME_COLLAPSE); }); if (actives.length === 0) { actives = null; } } var container = SelectorEngine.findOne(this._selector); if (actives) { var tempActiveData = actives.find(function (elem) { return container !== elem; }); activesData = tempActiveData ? Data.getData(tempActiveData, DATA_KEY$3) : null; if (activesData && activesData._isTransitioning) { return; } } var startEvent = EventHandler.trigger(this._element, EVENT_SHOW); if (startEvent.defaultPrevented) { return; } if (actives) { actives.forEach(function (elemActive) { if (container !== elemActive) { Collapse.collapseInterface(elemActive, 'hide'); } if (!activesData) { Data.setData(elemActive, DATA_KEY$3, null); } }); } var dimension = this._getDimension(); this._element.classList.remove(CLASS_NAME_COLLAPSE); this._element.classList.add(CLASS_NAME_COLLAPSING); this._element.style[dimension] = 0; if (this._triggerArray.length) { this._triggerArray.forEach(function (element) { element.classList.remove(CLASS_NAME_COLLAPSED); element.setAttribute('aria-expanded', true); }); } this.setTransitioning(true); var complete = function complete() { _this2._element.classList.remove(CLASS_NAME_COLLAPSING); _this2._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$1); _this2._element.style[dimension] = ''; _this2.setTransitioning(false); EventHandler.trigger(_this2._element, EVENT_SHOWN); }; var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1); var scrollSize = "scroll" + capitalizedDimension; var transitionDuration = getTransitionDurationFromElement(this._element); EventHandler.one(this._element, 'transitionend', complete); emulateTransitionEnd(this._element, transitionDuration); this._element.style[dimension] = this._element[scrollSize] + "px"; }; _proto.hide = function hide() { var _this3 = this; if (this._isTransitioning || !this._element.classList.contains(CLASS_NAME_SHOW$1)) { return; } var startEvent = EventHandler.trigger(this._element, EVENT_HIDE); if (startEvent.defaultPrevented) { return; } var dimension = this._getDimension(); this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px"; reflow(this._element); this._element.classList.add(CLASS_NAME_COLLAPSING); this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$1); var triggerArrayLength = this._triggerArray.length; if (triggerArrayLength > 0) { for (var i = 0; i < triggerArrayLength; i++) { var trigger = this._triggerArray[i]; var elem = getElementFromSelector(trigger); if (elem && !elem.classList.contains(CLASS_NAME_SHOW$1)) { trigger.classList.add(CLASS_NAME_COLLAPSED); trigger.setAttribute('aria-expanded', false); } } } this.setTransitioning(true); var complete = function complete() { _this3.setTransitioning(false); _this3._element.classList.remove(CLASS_NAME_COLLAPSING); _this3._element.classList.add(CLASS_NAME_COLLAPSE); EventHandler.trigger(_this3._element, EVENT_HIDDEN); }; this._element.style[dimension] = ''; var transitionDuration = getTransitionDurationFromElement(this._element); EventHandler.one(this._element, 'transitionend', complete); emulateTransitionEnd(this._element, transitionDuration); }; _proto.setTransitioning = function setTransitioning(isTransitioning) { this._isTransitioning = isTransitioning; }; _proto.dispose = function dispose() { _BaseComponent.prototype.dispose.call(this); this._config = null; this._parent = null; this._triggerArray = null; this._isTransitioning = null; } // Private ; _proto._getConfig = function _getConfig(config) { config = _extends({}, Default$1, config); config.toggle = Boolean(config.toggle); // Coerce string values typeCheckConfig(NAME$3, config, DefaultType$1); return config; }; _proto._getDimension = function _getDimension() { return this._element.classList.contains(WIDTH) ? WIDTH : HEIGHT; }; _proto._getParent = function _getParent() { var _this4 = this; var parent = this._config.parent; if (isElement(parent)) { // it's a jQuery object if (typeof parent.jquery !== 'undefined' || typeof parent[0] !== 'undefined') { parent = parent[0]; } } else { parent = SelectorEngine.findOne(parent); } var selector = SELECTOR_DATA_TOGGLE$1 + "[data-bs-parent=\"" + parent + "\"]"; SelectorEngine.find(selector, parent).forEach(function (element) { var selected = getElementFromSelector(element); _this4._addAriaAndCollapsedClass(selected, [element]); }); return parent; }; _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) { if (!element || !triggerArray.length) { return; } var isOpen = element.classList.contains(CLASS_NAME_SHOW$1); triggerArray.forEach(function (elem) { if (isOpen) { elem.classList.remove(CLASS_NAME_COLLAPSED); } else { elem.classList.add(CLASS_NAME_COLLAPSED); } elem.setAttribute('aria-expanded', isOpen); }); } // Static ; Collapse.collapseInterface = function collapseInterface(element, config) { var data = Data.getData(element, DATA_KEY$3); var _config = _extends({}, Default$1, Manipulator.getDataAttributes(element), typeof config === 'object' && config ? config : {}); if (!data && _config.toggle && typeof config === 'string' && /show|hide/.test(config)) { _config.toggle = false; } if (!data) { data = new Collapse(element, _config); } if (typeof config === 'string') { if (typeof data[config] === 'undefined') { throw new TypeError("No method named \"" + config + "\""); } data[config](); } }; Collapse.jQueryInterface = function jQueryInterface(config) { return this.each(function () { Collapse.collapseInterface(this, config); }); }; _createClass(Collapse, null, [{ key: "Default", get: function get() { return Default$1; } }, { key: "DATA_KEY", get: function get() { return DATA_KEY$3; } }]); return Collapse; }(BaseComponent); /** * ------------------------------------------------------------------------ * Data Api implementation * ------------------------------------------------------------------------ */ EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$1, function (event) { // preventDefault only for elements (which change the URL) not inside the collapsible element if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') { event.preventDefault(); } var triggerData = Manipulator.getDataAttributes(this); var selector = getSelectorFromElement(this); var selectorElements = SelectorEngine.find(selector); selectorElements.forEach(function (element) { var data = Data.getData(element, DATA_KEY$3); var 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.collapseInterface(element, config); }); }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ * add .Collapse to jQuery only if jQuery is present */ defineJQueryPlugin(NAME$3, Collapse); /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var NAME$4 = 'dropdown'; var DATA_KEY$4 = 'bs.dropdown'; var EVENT_KEY$4 = "." + DATA_KEY$4; var DATA_API_KEY$4 = '.data-api'; var ESCAPE_KEY = 'Escape'; var SPACE_KEY = 'Space'; var TAB_KEY = 'Tab'; var ARROW_UP_KEY = 'ArrowUp'; var ARROW_DOWN_KEY = 'ArrowDown'; var RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEY + "|" + ARROW_DOWN_KEY + "|" + ESCAPE_KEY); 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_DROPEND = 'dropend'; var CLASS_NAME_DROPSTART = 'dropstart'; var CLASS_NAME_NAVBAR = 'navbar'; var SELECTOR_DATA_TOGGLE$2 = '[data-bs-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 = isRTL ? 'top-end' : 'top-start'; var PLACEMENT_TOPEND = isRTL ? 'top-start' : 'top-end'; var PLACEMENT_BOTTOM = isRTL ? 'bottom-end' : 'bottom-start'; var PLACEMENT_BOTTOMEND = isRTL ? 'bottom-start' : 'bottom-end'; var PLACEMENT_RIGHT = isRTL ? 'left-start' : 'right-start'; var PLACEMENT_LEFT = isRTL ? 'right-start' : 'left-start'; var Default$2 = { offset: [0, 2], flip: true, boundary: 'clippingParents', reference: 'toggle', display: 'dynamic', popperConfig: null }; var DefaultType$2 = { offset: '(array|string|function)', flip: 'boolean', boundary: '(string|element)', reference: '(string|element|object)', display: 'string', popperConfig: '(null|object|function)' }; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ var Dropdown = /*#__PURE__*/function (_BaseComponent) { _inheritsLoose(Dropdown, _BaseComponent); function Dropdown(element, config) { var _this; _this = _BaseComponent.call(this, element) || this; _this._popper = null; _this._config = _this._getConfig(config); _this._menu = _this._getMenuElement(); _this._inNavbar = _this._detectNavbar(); _this._addEventListeners(); return _this; } // Getters var _proto = Dropdown.prototype; // Public _proto.toggle = function toggle() { if (this._element.disabled || this._element.classList.contains(CLASS_NAME_DISABLED)) { return; } var isActive = this._element.classList.contains(CLASS_NAME_SHOW$2); Dropdown.clearMenus(); if (isActive) { return; } this.show(); }; _proto.show = function show() { if (this._element.disabled || this._element.classList.contains(CLASS_NAME_DISABLED) || this._menu.classList.contains(CLASS_NAME_SHOW$2)) { return; } var parent = Dropdown.getParentFromElement(this._element); var relatedTarget = { relatedTarget: this._element }; var showEvent = EventHandler.trigger(this._element, EVENT_SHOW$1, relatedTarget); if (showEvent.defaultPrevented) { return; } // Totally disable Popper for Dropdowns in Navbar 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; if (this._config.reference === 'parent') { referenceElement = parent; } else if (isElement(this._config.reference)) { referenceElement = this._config.reference; // Check if it's jQuery element if (typeof this._config.reference.jquery !== 'undefined') { referenceElement = this._config.reference[0]; } } else if (typeof this._config.reference === 'object') { referenceElement = this._config.reference; } var popperConfig = this._getPopperConfig(); var isDisplayStatic = popperConfig.modifiers.find(function (modifier) { return modifier.name === 'applyStyles' && modifier.enabled === false; }); this._popper = Popper.createPopper(referenceElement, this._menu, popperConfig); if (isDisplayStatic) { Manipulator.setDataAttribute(this._menu, 'popper', 'static'); } } // 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 && !parent.closest(SELECTOR_NAVBAR_NAV)) { var _ref; (_ref = []).concat.apply(_ref, document.body.children).forEach(function (elem) { return EventHandler.on(elem, 'mouseover', null, noop()); }); } this._element.focus(); this._element.setAttribute('aria-expanded', true); this._menu.classList.toggle(CLASS_NAME_SHOW$2); this._element.classList.toggle(CLASS_NAME_SHOW$2); EventHandler.trigger(this._element, EVENT_SHOWN$1, relatedTarget); }; _proto.hide = function hide() { if (this._element.disabled || this._element.classList.contains(CLASS_NAME_DISABLED) || !this._menu.classList.contains(CLASS_NAME_SHOW$2)) { return; } var relatedTarget = { relatedTarget: this._element }; var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$1, relatedTarget); if (hideEvent.defaultPrevented) { return; } if (this._popper) { this._popper.destroy(); } this._menu.classList.toggle(CLASS_NAME_SHOW$2); this._element.classList.toggle(CLASS_NAME_SHOW$2); Manipulator.removeDataAttribute(this._menu, 'popper'); EventHandler.trigger(this._element, EVENT_HIDDEN$1, relatedTarget); }; _proto.dispose = function dispose() { _BaseComponent.prototype.dispose.call(this); EventHandler.off(this._element, EVENT_KEY$4); this._menu = null; if (this._popper) { this._popper.destroy(); this._popper = null; } }; _proto.update = function update() { this._inNavbar = this._detectNavbar(); if (this._popper) { this._popper.update(); } } // Private ; _proto._addEventListeners = function _addEventListeners() { var _this2 = this; EventHandler.on(this._element, EVENT_CLICK, function (event) { event.preventDefault(); event.stopPropagation(); _this2.toggle(); }); }; _proto._getConfig = function _getConfig(config) { config = _extends({}, this.constructor.Default, Manipulator.getDataAttributes(this._element), config); typeCheckConfig(NAME$4, 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$4.toUpperCase() + ": Option \"reference\" provided type \"object\" without a required \"getBoundingClientRect\" method."); } return config; }; _proto._getMenuElement = function _getMenuElement() { return SelectorEngine.next(this._element, SELECTOR_MENU)[0]; }; _proto._getPlacement = function _getPlacement() { var parentDropdown = this._element.parentNode; if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) { return PLACEMENT_RIGHT; } if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) { return PLACEMENT_LEFT; } // We need to trim the value because custom properties can also include spaces var isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end'; if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) { return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP; } return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM; }; _proto._detectNavbar = function _detectNavbar() { return this._element.closest("." + CLASS_NAME_NAVBAR) !== null; }; _proto._getOffset = function _getOffset() { var _this3 = this; var offset = this._config.offset; if (typeof offset === 'string') { return offset.split(',').map(function (val) { return Number.parseInt(val, 10); }); } if (typeof offset === 'function') { return function (popperData) { return offset(popperData, _this3._element); }; } return offset; }; _proto._getPopperConfig = function _getPopperConfig() { var defaultBsPopperConfig = { placement: this._getPlacement(), modifiers: [{ name: 'preventOverflow', options: { altBoundary: this._config.flip, boundary: this._config.boundary } }, { name: 'offset', options: { offset: this._getOffset() } }] }; // Disable Popper if we have a static display if (this._config.display === 'static') { defaultBsPopperConfig.modifiers = [{ name: 'applyStyles', enabled: false }]; } return _extends({}, defaultBsPopperConfig, typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig); } // Static ; Dropdown.dropdownInterface = function dropdownInterface(element, config) { var data = Data.getData(element, DATA_KEY$4); var _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 + "\""); } data[config](); } }; Dropdown.jQueryInterface = function jQueryInterface(config) { return this.each(function () { Dropdown.dropdownInterface(this, config); }); }; Dropdown.clearMenus = function clearMenus(event) { if (event && (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY)) { return; } var toggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE$2); for (var i = 0, len = toggles.length; i < len; i++) { var context = Data.getData(toggles[i], DATA_KEY$4); var relatedTarget = { relatedTarget: toggles[i] }; if (event && event.type === 'click') { relatedTarget.clickEvent = event; } if (!context) { continue; } var dropdownMenu = context._menu; if (!toggles[i].classList.contains(CLASS_NAME_SHOW$2)) { continue; } if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.key === TAB_KEY) && dropdownMenu.contains(event.target)) { continue; } var hideEvent = EventHandler.trigger(toggles[i], EVENT_HIDE$1, relatedTarget); if (hideEvent.defaultPrevented) { continue; } // If this is a touch-enabled device we remove the extra // empty mouseover listeners we added for iOS support if ('ontouchstart' in document.documentElement) { var _ref2; (_ref2 = []).concat.apply(_ref2, document.body.children).forEach(function (elem) { return EventHandler.off(elem, 'mouseover', null, noop()); }); } toggles[i].setAttribute('aria-expanded', 'false'); if (context._popper) { context._popper.destroy(); } dropdownMenu.classList.remove(CLASS_NAME_SHOW$2); toggles[i].classList.remove(CLASS_NAME_SHOW$2); Manipulator.removeDataAttribute(dropdownMenu, 'popper'); EventHandler.trigger(toggles[i], EVENT_HIDDEN$1, relatedTarget); } }; Dropdown.getParentFromElement = function getParentFromElement(element) { return getElementFromSelector(element) || element.parentNode; }; Dropdown.dataApiKeydownHandler = function dataApiKeydownHandler(event) { // If not input/textarea: // - And not a key in REGEXP_KEYDOWN => not a dropdown command // If input/textarea: // - If space key => not a dropdown command // - 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.key === SPACE_KEY || event.key !== ESCAPE_KEY && (event.key !== ARROW_DOWN_KEY && event.key !== ARROW_UP_KEY || event.target.closest(SELECTOR_MENU)) : !REGEXP_KEYDOWN.test(event.key)) { return; } event.preventDefault(); event.stopPropagation(); if (this.disabled || this.classList.contains(CLASS_NAME_DISABLED)) { return; } var parent = Dropdown.getParentFromElement(this); var isActive = this.classList.contains(CLASS_NAME_SHOW$2); if (event.key === ESCAPE_KEY) { var button = this.matches(SELECTOR_DATA_TOGGLE$2) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$2)[0]; button.focus(); Dropdown.clearMenus(); return; } if (!isActive && (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY)) { var _button = this.matches(SELECTOR_DATA_TOGGLE$2) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$2)[0]; _button.click(); return; } if (!isActive || event.key === SPACE_KEY) { Dropdown.clearMenus(); return; } var items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, parent).filter(isVisible); if (!items.length) { return; } var index = items.indexOf(event.target); // Up if (event.key === ARROW_UP_KEY && index > 0) { index--; } // Down if (event.key === ARROW_DOWN_KEY && index < items.length - 1) { index++; } // index is -1 if the first keydown is an ArrowUp index = index === -1 ? 0 : index; items[index].focus(); }; _createClass(Dropdown, null, [{ key: "Default", get: function get() { return Default$2; } }, { key: "DefaultType", get: function get() { return DefaultType$2; } }, { key: "DATA_KEY", get: function get() { return DATA_KEY$4; } }]); return Dropdown; }(BaseComponent); /** * ------------------------------------------------------------------------ * Data Api implementation * ------------------------------------------------------------------------ */ EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$2, Dropdown.dataApiKeydownHandler); EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler); EventHandler.on(document, EVENT_CLICK_DATA_API$4, Dropdown.clearMenus); EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus); EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$2, function (event) { event.preventDefault(); event.stopPropagation(); Dropdown.dropdownInterface(this, 'toggle'); }); EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_FORM_CHILD, function (e) { return e.stopPropagation(); }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ * add .Dropdown to jQuery only if jQuery is present */ defineJQueryPlugin(NAME$4, Dropdown); /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var NAME$5 = 'modal'; var DATA_KEY$5 = 'bs.modal'; var EVENT_KEY$5 = "." + DATA_KEY$5; var DATA_API_KEY$5 = '.data-api'; var ESCAPE_KEY$1 = 'Escape'; var Default$3 = { backdrop: true, keyboard: true, focus: true }; var DefaultType$3 = { backdrop: '(boolean|string)', keyboard: '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_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-bs-toggle="modal"]'; var SELECTOR_DATA_DISMISS = '[data-bs-dismiss="modal"]'; var SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'; var SELECTOR_STICKY_CONTENT = '.sticky-top'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ var Modal = /*#__PURE__*/function (_BaseComponent) { _inheritsLoose(Modal, _BaseComponent); function Modal(element, config) { var _this; _this = _BaseComponent.call(this, element) || this; _this._config = _this._getConfig(config); _this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, element); _this._backdrop = null; _this._isShown = false; _this._isBodyOverflowing = false; _this._ignoreBackdropClick = false; _this._isTransitioning = false; _this._scrollbarWidth = 0; return _this; } // Getters var _proto = Modal.prototype; // Public _proto.toggle = function toggle(relatedTarget) { return this._isShown ? this.hide() : this.show(relatedTarget); }; _proto.show = function show(relatedTarget) { var _this2 = this; if (this._isShown || this._isTransitioning) { return; } if (this._element.classList.contains(CLASS_NAME_FADE$1)) { this._isTransitioning = true; } var showEvent = EventHandler.trigger(this._element, EVENT_SHOW$2, { relatedTarget: relatedTarget }); if (this._isShown || showEvent.defaultPrevented) { return; } this._isShown = true; this._checkScrollbar(); this._setScrollbar(); this._adjustDialog(); this._setEscapeEvent(); this._setResizeEvent(); EventHandler.on(this._element, EVENT_CLICK_DISMISS, SELECTOR_DATA_DISMISS, function (event) { return _this2.hide(event); }); EventHandler.on(this._dialog, EVENT_MOUSEDOWN_DISMISS, function () { EventHandler.one(_this2._element, EVENT_MOUSEUP_DISMISS, function (event) { if (event.target === _this2._element) { _this2._ignoreBackdropClick = true; } }); }); this._showBackdrop(function () { return _this2._showElement(relatedTarget); }); }; _proto.hide = function hide(event) { var _this3 = this; if (event) { event.preventDefault(); } if (!this._isShown || this._isTransitioning) { return; } var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$2); if (hideEvent.defaultPrevented) { return; } this._isShown = false; var transition = this._element.classList.contains(CLASS_NAME_FADE$1); if (transition) { this._isTransitioning = true; } this._setEscapeEvent(); this._setResizeEvent(); EventHandler.off(document, EVENT_FOCUSIN); this._element.classList.remove(CLASS_NAME_SHOW$3); EventHandler.off(this._element, EVENT_CLICK_DISMISS); EventHandler.off(this._dialog, EVENT_MOUSEDOWN_DISMISS); if (transition) { var transitionDuration = getTransitionDurationFromElement(this._element); EventHandler.one(this._element, 'transitionend', function (event) { return _this3._hideModal(event); }); emulateTransitionEnd(this._element, transitionDuration); } else { this._hideModal(); } }; _proto.dispose = function dispose() { [window, this._element, this._dialog].forEach(function (htmlElement) { return EventHandler.off(htmlElement, EVENT_KEY$5); }); _BaseComponent.prototype.dispose.call(this); /** * `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 */ EventHandler.off(document, EVENT_FOCUSIN); this._config = null; this._dialog = null; this._backdrop = null; this._isShown = null; this._isBodyOverflowing = null; this._ignoreBackdropClick = null; this._isTransitioning = null; this._scrollbarWidth = null; }; _proto.handleUpdate = function handleUpdate() { this._adjustDialog(); } // Private ; _proto._getConfig = function _getConfig(config) { config = _extends({}, Default$3, config); typeCheckConfig(NAME$5, config, DefaultType$3); return config; }; _proto._showElement = function _showElement(relatedTarget) { var _this4 = this; var transition = this._element.classList.contains(CLASS_NAME_FADE$1); var 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 document.body.appendChild(this._element); } this._element.style.display = 'block'; this._element.removeAttribute('aria-hidden'); this._element.setAttribute('aria-modal', true); this._element.setAttribute('role', 'dialog'); this._element.scrollTop = 0; if (modalBody) { modalBody.scrollTop = 0; } if (transition) { reflow(this._element); } this._element.classList.add(CLASS_NAME_SHOW$3); if (this._config.focus) { this._enforceFocus(); } var transitionComplete = function transitionComplete() { if (_this4._config.focus) { _this4._element.focus(); } _this4._isTransitioning = false; EventHandler.trigger(_this4._element, EVENT_SHOWN$2, { relatedTarget: relatedTarget }); }; if (transition) { var transitionDuration = getTransitionDurationFromElement(this._dialog); EventHandler.one(this._dialog, 'transitionend', transitionComplete); emulateTransitionEnd(this._dialog, transitionDuration); } else { transitionComplete(); } }; _proto._enforceFocus = function _enforceFocus() { var _this5 = this; EventHandler.off(document, EVENT_FOCUSIN); // guard against infinite focus loop EventHandler.on(document, EVENT_FOCUSIN, function (event) { if (document !== event.target && _this5._element !== event.target && !_this5._element.contains(event.target)) { _this5._element.focus(); } }); }; _proto._setEscapeEvent = function _setEscapeEvent() { var _this6 = this; if (this._isShown) { EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, function (event) { if (_this6._config.keyboard && event.key === ESCAPE_KEY$1) { event.preventDefault(); _this6.hide(); } else if (!_this6._config.keyboard && event.key === ESCAPE_KEY$1) { _this6._triggerBackdropTransition(); } }); } else { EventHandler.off(this._element, EVENT_KEYDOWN_DISMISS); } }; _proto._setResizeEvent = function _setResizeEvent() { var _this7 = this; if (this._isShown) { EventHandler.on(window, EVENT_RESIZE, function () { return _this7._adjustDialog(); }); } else { EventHandler.off(window, EVENT_RESIZE); } }; _proto._hideModal = function _hideModal() { var _this8 = this; this._element.style.display = 'none'; this._element.setAttribute('aria-hidden', true); this._element.removeAttribute('aria-modal'); this._element.removeAttribute('role'); this._isTransitioning = false; this._showBackdrop(function () { document.body.classList.remove(CLASS_NAME_OPEN); _this8._resetAdjustments(); _this8._resetScrollbar(); EventHandler.trigger(_this8._element, EVENT_HIDDEN$2); }); }; _proto._removeBackdrop = function _removeBackdrop() { this._backdrop.parentNode.removeChild(this._backdrop); this._backdrop = null; }; _proto._showBackdrop = function _showBackdrop(callback) { var _this9 = this; var animate = this._element.classList.contains(CLASS_NAME_FADE$1) ? CLASS_NAME_FADE$1 : ''; if (this._isShown && this._config.backdrop) { this._backdrop = document.createElement('div'); this._backdrop.className = CLASS_NAME_BACKDROP; if (animate) { this._backdrop.classList.add(animate); } document.body.appendChild(this._backdrop); EventHandler.on(this._element, EVENT_CLICK_DISMISS, function (event) { if (_this9._ignoreBackdropClick) { _this9._ignoreBackdropClick = false; return; } if (event.target !== event.currentTarget) { return; } if (_this9._config.backdrop === 'static') { _this9._triggerBackdropTransition(); } else { _this9.hide(); } }); if (animate) { reflow(this._backdrop); } this._backdrop.classList.add(CLASS_NAME_SHOW$3); if (!animate) { callback(); return; } var backdropTransitionDuration = getTransitionDurationFromElement(this._backdrop); EventHandler.one(this._backdrop, 'transitionend', callback); emulateTransitionEnd(this._backdrop, backdropTransitionDuration); } else if (!this._isShown && this._backdrop) { this._backdrop.classList.remove(CLASS_NAME_SHOW$3); var callbackRemove = function callbackRemove() { _this9._removeBackdrop(); callback(); }; if (this._element.classList.contains(CLASS_NAME_FADE$1)) { var _backdropTransitionDuration = getTransitionDurationFromElement(this._backdrop); EventHandler.one(this._backdrop, 'transitionend', callbackRemove); emulateTransitionEnd(this._backdrop, _backdropTransitionDuration); } else { callbackRemove(); } } else { callback(); } }; _proto._triggerBackdropTransition = function _triggerBackdropTransition() { var _this10 = this; var hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED); if (hideEvent.defaultPrevented) { 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 = getTransitionDurationFromElement(this._dialog); EventHandler.off(this._element, 'transitionend'); EventHandler.one(this._element, 'transitionend', function () { _this10._element.classList.remove(CLASS_NAME_STATIC); if (!isModalOverflowing) { EventHandler.one(_this10._element, 'transitionend', function () { _this10._element.style.overflowY = ''; }); emulateTransitionEnd(_this10._element, modalTransitionDuration); } }); emulateTransitionEnd(this._element, modalTransitionDuration); this._element.focus(); } // ---------------------------------------------------------------------- // the following methods are used to handle overflowing modals // ---------------------------------------------------------------------- ; _proto._adjustDialog = function _adjustDialog() { var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; if (!this._isBodyOverflowing && isModalOverflowing && !isRTL || this._isBodyOverflowing && !isModalOverflowing && isRTL) { this._element.style.paddingLeft = this._scrollbarWidth + "px"; } if (this._isBodyOverflowing && !isModalOverflowing && !isRTL || !this._isBodyOverflowing && isModalOverflowing && isRTL) { this._element.style.paddingRight = this._scrollbarWidth + "px"; } }; _proto._resetAdjustments = function _resetAdjustments() { this._element.style.paddingLeft = ''; this._element.style.paddingRight = ''; }; _proto._checkScrollbar = function _checkScrollbar() { var rect = document.body.getBoundingClientRect(); this._isBodyOverflowing = Math.round(rect.left + rect.right) < window.innerWidth; this._scrollbarWidth = this._getScrollbarWidth(); }; _proto._setScrollbar = function _setScrollbar() { var _this11 = this; if (this._isBodyOverflowing) { this._setElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight', function (calculatedValue) { return calculatedValue + _this11._scrollbarWidth; }); this._setElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight', function (calculatedValue) { return calculatedValue - _this11._scrollbarWidth; }); this._setElementAttributes('body', 'paddingRight', function (calculatedValue) { return calculatedValue + _this11._scrollbarWidth; }); } document.body.classList.add(CLASS_NAME_OPEN); }; _proto._setElementAttributes = function _setElementAttributes(selector, styleProp, callback) { SelectorEngine.find(selector).forEach(function (element) { var actualValue = element.style[styleProp]; var calculatedValue = window.getComputedStyle(element)[styleProp]; Manipulator.setDataAttribute(element, styleProp, actualValue); element.style[styleProp] = callback(Number.parseFloat(calculatedValue)) + 'px'; }); }; _proto._resetScrollbar = function _resetScrollbar() { this._resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight'); this._resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight'); this._resetElementAttributes('body', 'paddingRight'); }; _proto._resetElementAttributes = function _resetElementAttributes(selector, styleProp) { SelectorEngine.find(selector).forEach(function (element) { var value = Manipulator.getDataAttribute(element, styleProp); if (typeof value === 'undefined' && element === document.body) { element.style[styleProp] = ''; } else { Manipulator.removeDataAttribute(element, styleProp); element.style[styleProp] = value; } }); }; _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 ; Modal.jQueryInterface = function jQueryInterface(config, relatedTarget) { return this.each(function () { var data = Data.getData(this, DATA_KEY$5); var _config = _extends({}, Default$3, Manipulator.getDataAttributes(this), typeof config === 'object' && config ? config : {}); if (!data) { data = new Modal(this, _config); } if (typeof config === 'string') { if (typeof data[config] === 'undefined') { throw new TypeError("No method named \"" + config + "\""); } data[config](relatedTarget); } }); }; _createClass(Modal, null, [{ key: "Default", get: function get() { return Default$3; } }, { key: "DATA_KEY", get: function get() { return DATA_KEY$5; } }]); return Modal; }(BaseComponent); /** * ------------------------------------------------------------------------ * Data Api implementation * ------------------------------------------------------------------------ */ EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_TOGGLE$3, function (event) { var _this12 = this; var target = getElementFromSelector(this); if (this.tagName === 'A' || this.tagName === 'AREA') { event.preventDefault(); } EventHandler.one(target, EVENT_SHOW$2, function (showEvent) { if (showEvent.defaultPrevented) { // only register focus restorer if modal will actually get shown return; } EventHandler.one(target, EVENT_HIDDEN$2, function () { if (isVisible(_this12)) { _this12.focus(); } }); }); var data = Data.getData(target, DATA_KEY$5); if (!data) { var config = _extends({}, Manipulator.getDataAttributes(target), Manipulator.getDataAttributes(this)); data = new Modal(target, config); } data.toggle(this); }); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ * add .Modal to jQuery only if jQuery is present */ defineJQueryPlugin(NAME$5, Modal); /** * -------------------------------------------------------------------------- * Bootstrap (v5.0.0-beta2): util/sanitizer.js * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) * -------------------------------------------------------------------------- */ var uriAttrs = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']); var 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 */ 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; var allowedAttribute = function allowedAttribute(attr, allowedAttributeList) { var 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; } 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 (regExp[i].test(attrName)) { return true; } } return false; }; var DefaultAllowlist = { // Global attributes allowed on any supplied element below. '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN], a: ['target', 'href', 'title', 'rel'], area: [], b: [], br: [], col: [], code: [], div: [], em: [], hr: [], h1: [], h2: [], h3: [], h4: [], h5: [], h6: [], i: [], img: ['src', 'srcset', 'alt', 'title', 'width', 'height'], li: [], ol: [], p: [], pre: [], s: [], small: [], span: [], sub: [], sup: [], strong: [], u: [], ul: [] }; function sanitizeHtml(unsafeHtml, allowList, sanitizeFn) { var _ref; if (!unsafeHtml.length) { return unsafeHtml; } if (sanitizeFn && typeof sanitizeFn === 'function') { return sanitizeFn(unsafeHtml); } var domParser = new window.DOMParser(); var createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); var allowlistKeys = Object.keys(allowList); var elements = (_ref = []).concat.apply(_ref, createdDocument.body.querySelectorAll('*')); var _loop = function _loop(i, len) { var _ref2; var el = elements[i]; var elName = el.nodeName.toLowerCase(); if (!allowlistKeys.includes(elName)) { el.parentNode.removeChild(el); return "continue"; } var attributeList = (_ref2 = []).concat.apply(_ref2, el.attributes); var allowedAttributes = [].concat(allowList['*'] || [], allowList[elName] || []); attributeList.forEach(function (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; } /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var NAME$6 = 'tooltip'; var DATA_KEY$6 = 'bs.tooltip'; var EVENT_KEY$6 = "." + DATA_KEY$6; var CLASS_PREFIX = 'bs-tooltip'; var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g'); var DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']); var DefaultType$4 = { animation: 'boolean', template: 'string', title: '(string|element|function)', trigger: 'string', delay: '(number|object)', html: 'boolean', selector: '(string|boolean)', placement: '(string|function)', offset: '(array|string|function)', container: '(string|element|boolean)', fallbackPlacements: 'array', boundary: '(string|element)', customClass: '(string|function)', sanitize: 'boolean', sanitizeFn: '(null|function)', allowList: 'object', popperConfig: '(null|object|function)' }; var AttachmentMap = { AUTO: 'auto', TOP: 'top', RIGHT: isRTL ? 'left' : 'right', BOTTOM: 'bottom', LEFT: isRTL ? 'right' : 'left' }; var Default$4 = { animation: true, template: '', trigger: 'hover focus', title: '', delay: 0, html: false, selector: false, placement: 'top', offset: [0, 0], container: false, fallbackPlacements: ['top', 'right', 'bottom', 'left'], boundary: 'clippingParents', customClass: '', sanitize: true, sanitizeFn: null, allowList: DefaultAllowlist, popperConfig: null }; var Event$1 = { 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 }; var CLASS_NAME_FADE$2 = 'fade'; var CLASS_NAME_MODAL = 'modal'; var CLASS_NAME_SHOW$4 = 'show'; var HOVER_STATE_SHOW = 'show'; var HOVER_STATE_OUT = 'out'; var SELECTOR_TOOLTIP_INNER = '.tooltip-inner'; var TRIGGER_HOVER = 'hover'; var TRIGGER_FOCUS = 'focus'; var TRIGGER_CLICK = 'click'; var TRIGGER_MANUAL = 'manual'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ var Tooltip = /*#__PURE__*/function (_BaseComponent) { _inheritsLoose(Tooltip, _BaseComponent); function Tooltip(element, config) { var _this; if (typeof Popper__namespace === 'undefined') { throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)'); } _this = _BaseComponent.call(this, element) || this; // private _this._isEnabled = true; _this._timeout = 0; _this._hoverState = ''; _this._activeTrigger = {}; _this._popper = null; // Protected _this.config = _this._getConfig(config); _this.tip = null; _this._setListeners(); return _this; } // Getters var _proto = Tooltip.prototype; // Public _proto.enable = function enable() { this._isEnabled = true; }; _proto.disable = function disable() { this._isEnabled = false; }; _proto.toggleEnabled = function toggleEnabled() { this._isEnabled = !this._isEnabled; }; _proto.toggle = function toggle(event) { if (!this._isEnabled) { return; } if (event) { var context = this._initializeOnDelegatedTarget(event); context._activeTrigger.click = !context._activeTrigger.click; if (context._isWithActiveTrigger()) { context._enter(null, context); } else { context._leave(null, context); } } else { if (this.getTipElement().classList.contains(CLASS_NAME_SHOW$4)) { this._leave(null, this); return; } this._enter(null, this); } }; _proto.dispose = function dispose() { clearTimeout(this._timeout); EventHandler.off(this._element, this.constructor.EVENT_KEY); EventHandler.off(this._element.closest("." + CLASS_NAME_MODAL), 'hide.bs.modal', this._hideModalHandler); 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.config = null; this.tip = null; _BaseComponent.prototype.dispose.call(this); }; _proto.show = function show() { var _this2 = this; if (this._element.style.display === 'none') { throw new Error('Please use show on visible elements'); } if (!(this.isWithContent() && this._isEnabled)) { return; } var showEvent = EventHandler.trigger(this._element, this.constructor.Event.SHOW); var shadowRoot = findShadowRoot(this._element); var isInTheDom = shadowRoot === null ? this._element.ownerDocument.documentElement.contains(this._element) : shadowRoot.contains(this._element); if (showEvent.defaultPrevented || !isInTheDom) { return; } var tip = this.getTipElement(); var tipId = getUID(this.constructor.NAME); tip.setAttribute('id', tipId); this._element.setAttribute('aria-describedby', tipId); this.setContent(); if (this.config.animation) { tip.classList.add(CLASS_NAME_FADE$2); } var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this._element) : this.config.placement; var attachment = this._getAttachment(placement); this._addAttachmentClass(attachment); var container = this._getContainer(); Data.setData(tip, this.constructor.DATA_KEY, this); if (!this._element.ownerDocument.documentElement.contains(this.tip)) { container.appendChild(tip); } EventHandler.trigger(this._element, this.constructor.Event.INSERTED); this._popper = Popper.createPopper(this._element, tip, this._getPopperConfig(attachment)); tip.classList.add(CLASS_NAME_SHOW$4); var customClass = typeof this.config.customClass === 'function' ? this.config.customClass() : this.config.customClass; if (customClass) { var _tip$classList; (_tip$classList = tip.classList).add.apply(_tip$classList, 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 ('ontouchstart' in document.documentElement) { var _ref; (_ref = []).concat.apply(_ref, document.body.children).forEach(function (element) { EventHandler.on(element, 'mouseover', noop()); }); } var complete = function complete() { var prevHoverState = _this2._hoverState; _this2._hoverState = null; EventHandler.trigger(_this2._element, _this2.constructor.Event.SHOWN); if (prevHoverState === HOVER_STATE_OUT) { _this2._leave(null, _this2); } }; if (this.tip.classList.contains(CLASS_NAME_FADE$2)) { var transitionDuration = getTransitionDurationFromElement(this.tip); EventHandler.one(this.tip, 'transitionend', complete); emulateTransitionEnd(this.tip, transitionDuration); } else { complete(); } }; _proto.hide = function hide() { var _this3 = this; if (!this._popper) { return; } var tip = this.getTipElement(); var complete = function complete() { if (_this3._hoverState !== HOVER_STATE_SHOW && tip.parentNode) { tip.parentNode.removeChild(tip); } _this3._cleanTipClass(); _this3._element.removeAttribute('aria-describedby'); EventHandler.trigger(_this3._element, _this3.constructor.Event.HIDDEN); if (_this3._popper) { _this3._popper.destroy(); _this3._popper = null; } }; var hideEvent = EventHandler.trigger(this._element, this.constructor.Event.HIDE); if (hideEvent.defaultPrevented) { return; } tip.classList.remove(CLASS_NAME_SHOW$4); // If this is a touch-enabled device we remove the extra // empty mouseover listeners we added for iOS support if ('ontouchstart' in document.documentElement) { var _ref2; (_ref2 = []).concat.apply(_ref2, document.body.children).forEach(function (element) { return EventHandler.off(element, 'mouseover', noop); }); } this._activeTrigger[TRIGGER_CLICK] = false; this._activeTrigger[TRIGGER_FOCUS] = false; this._activeTrigger[TRIGGER_HOVER] = false; if (this.tip.classList.contains(CLASS_NAME_FADE$2)) { var transitionDuration = getTransitionDurationFromElement(tip); EventHandler.one(tip, 'transitionend', complete); emulateTransitionEnd(tip, transitionDuration); } else { complete(); } this._hoverState = ''; }; _proto.update = function update() { if (this._popper !== null) { this._popper.update(); } } // Protected ; _proto.isWithContent = function isWithContent() { return Boolean(this.getTitle()); }; _proto.getTipElement = function getTipElement() { if (this.tip) { return this.tip; } var 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(SelectorEngine.findOne(SELECTOR_TOOLTIP_INNER, tip), this.getTitle()); tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$4); }; _proto.setElementContent = function setElementContent(element, content) { if (element === null) { return; } if (typeof content === 'object' && isElement(content)) { if (content.jquery) { content = content[0]; } // content is a DOM node or a jQuery if (this.config.html) { if (content.parentNode !== element) { element.innerHTML = ''; element.appendChild(content); } } else { element.textContent = content.textContent; } return; } if (this.config.html) { if (this.config.sanitize) { content = sanitizeHtml(content, this.config.allowList, this.config.sanitizeFn); } element.innerHTML = content; } else { element.textContent = content; } }; _proto.getTitle = function getTitle() { var 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; } return title; }; _proto.updateAttachment = function updateAttachment(attachment) { if (attachment === 'right') { return 'end'; } if (attachment === 'left') { return 'start'; } return attachment; } // Private ; _proto._initializeOnDelegatedTarget = function _initializeOnDelegatedTarget(event, context) { var dataKey = this.constructor.DATA_KEY; context = context || Data.getData(event.delegateTarget, dataKey); if (!context) { context = new this.constructor(event.delegateTarget, this._getDelegateConfig()); Data.setData(event.delegateTarget, dataKey, context); } return context; }; _proto._getOffset = function _getOffset() { var _this4 = this; var offset = this.config.offset; if (typeof offset === 'string') { return offset.split(',').map(function (val) { return Number.parseInt(val, 10); }); } if (typeof offset === 'function') { return function (popperData) { return offset(popperData, _this4._element); }; } return offset; }; _proto._getPopperConfig = function _getPopperConfig(attachment) { var _this5 = this; var defaultBsPopperConfig = { placement: attachment, modifiers: [{ name: 'flip', options: { altBoundary: true, 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: function fn(data) { return _this5._handlePopperPlacementChange(data); } }], onFirstUpdate: function onFirstUpdate(data) { if (data.options.placement !== data.placement) { _this5._handlePopperPlacementChange(data); } } }; return _extends({}, defaultBsPopperConfig, typeof this.config.popperConfig === 'function' ? this.config.popperConfig(defaultBsPopperConfig) : this.config.popperConfig); }; _proto._addAttachmentClass = function _addAttachmentClass(attachment) { this.getTipElement().classList.add(CLASS_PREFIX + "-" + this.updateAttachment(attachment)); }; _proto._getContainer = function _getContainer() { if (this.config.container === false) { return document.body; } if (isElement(this.config.container)) { return this.config.container; } return SelectorEngine.findOne(this.config.container); }; _proto._getAttachment = function _getAttachment(placement) { return AttachmentMap[placement.toUpperCase()]; }; _proto._setListeners = function _setListeners() { var _this6 = this; var triggers = this.config.trigger.split(' '); triggers.forEach(function (trigger) { if (trigger === 'click') { EventHandler.on(_this6._element, _this6.constructor.Event.CLICK, _this6.config.selector, function (event) { return _this6.toggle(event); }); } else if (trigger !== TRIGGER_MANUAL) { var eventIn = trigger === TRIGGER_HOVER ? _this6.constructor.Event.MOUSEENTER : _this6.constructor.Event.FOCUSIN; var eventOut = trigger === TRIGGER_HOVER ? _this6.constructor.Event.MOUSELEAVE : _this6.constructor.Event.FOCUSOUT; EventHandler.on(_this6._element, eventIn, _this6.config.selector, function (event) { return _this6._enter(event); }); EventHandler.on(_this6._element, eventOut, _this6.config.selector, function (event) { return _this6._leave(event); }); } }); this._hideModalHandler = function () { if (_this6._element) { _this6.hide(); } }; EventHandler.on(this._element.closest("." + CLASS_NAME_MODAL), 'hide.bs.modal', this._hideModalHandler); if (this.config.selector) { this.config = _extends({}, this.config, { trigger: 'manual', selector: '' }); } else { this._fixTitle(); } }; _proto._fixTitle = function _fixTitle() { var title = this._element.getAttribute('title'); var originalTitleType = typeof this._element.getAttribute('data-bs-original-title'); if (title || originalTitleType !== 'string') { this._element.setAttribute('data-bs-original-title', title || ''); if (title && !this._element.getAttribute('aria-label') && !this._element.textContent) { this._element.setAttribute('aria-label', title); } this._element.setAttribute('title', ''); } }; _proto._enter = function _enter(event, context) { context = this._initializeOnDelegatedTarget(event, context); if (event) { context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true; } if (context.getTipElement().classList.contains(CLASS_NAME_SHOW$4) || context._hoverState === HOVER_STATE_SHOW) { context._hoverState = HOVER_STATE_SHOW; return; } clearTimeout(context._timeout); context._hoverState = HOVER_STATE_SHOW; if (!context.config.delay || !context.config.delay.show) { context.show(); return; } context._timeout = setTimeout(function () { if (context._hoverState === HOVER_STATE_SHOW) { context.show(); } }, context.config.delay.show); }; _proto._leave = function _leave(event, context) { context = this._initializeOnDelegatedTarget(event, context); if (event) { context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = false; } if (context._isWithActiveTrigger()) { return; } clearTimeout(context._timeout); context._hoverState = HOVER_STATE_OUT; if (!context.config.delay || !context.config.delay.hide) { context.hide(); return; } context._timeout = setTimeout(function () { if (context._hoverState === HOVER_STATE_OUT) { context.hide(); } }, context.config.delay.hide); }; _proto._isWithActiveTrigger = function _isWithActiveTrigger() { for (var trigger in this._activeTrigger) { if (this._activeTrigger[trigger]) { return true; } } return false; }; _proto._getConfig = function _getConfig(config) { var dataAttributes = Manipulator.getDataAttributes(this._element); Object.keys(dataAttributes).forEach(function (dataAttr) { if (DISALLOWED_ATTRIBUTES.has(dataAttr)) { delete dataAttributes[dataAttr]; } }); if (config && typeof config.container === 'object' && config.container.jquery) { config.container = config.container[0]; } config = _extends({}, this.constructor.Default, dataAttributes, typeof config === 'object' && config ? config : {}); if (typeof config.delay === 'number') { config.delay = { show: config.delay, hide: config.delay }; } if (typeof config.title === 'number') { config.title = config.title.toString(); } if (typeof config.content === 'number') { config.content = config.content.toString(); } typeCheckConfig(NAME$6, config, this.constructor.DefaultType); if (config.sanitize) { config.template = sanitizeHtml(config.template, config.allowList, config.sanitizeFn); } return config; }; _proto._getDelegateConfig = function _getDelegateConfig() { var config = {}; if (this.config) { for (var 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 = this.getTipElement(); var tabClass = tip.getAttribute('class').match(BSCLS_PREFIX_REGEX); if (tabClass !== null && tabClass.length > 0) { tabClass.map(function (token) { return token.trim(); }).forEach(function (tClass) { return tip.classList.remove(tClass); }); } }; _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) { var state = popperData.state; if (!state) { return; } this.tip = state.elements.popper; this._cleanTipClass(); this._addAttachmentClass(this._getAttachment(state.placement)); } // Static ; Tooltip.jQueryInterface = function jQueryInterface(config) { return this.each(function () { var data = Data.getData(this, DATA_KEY$6); var _config = typeof config === 'object' && config; if (!data && /dispose|hide/.test(config)) { return; } if (!data) { data = new Tooltip(this, _config); } if (typeof config === 'string') { if (typeof data[config] === 'undefined') { throw new TypeError("No method named \"" + config + "\""); } data[config](); } }); }; _createClass(Tooltip, null, [{ 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$1; } }, { key: "EVENT_KEY", get: function get() { return EVENT_KEY$6; } }, { key: "DefaultType", get: function get() { return DefaultType$4; } }]); return Tooltip; }(BaseComponent); /** * ------------------------------------------------------------------------ * jQuery * ------------------------------------------------------------------------ * add .Tooltip to jQuery only if jQuery is present */ defineJQueryPlugin(NAME$6, Tooltip); /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var NAME$7 = 'popover'; var DATA_KEY$7 = 'bs.popover'; var EVENT_KEY$7 = "." + DATA_KEY$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, { placement: 'right', offset: [0, 8], trigger: 'click', content: '', template: '' }); var DefaultType$5 = _extends({}, Tooltip.DefaultType, { content: '(string|element|function)' }); var Event$2 = { 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 }; var CLASS_NAME_FADE$3 = 'fade'; var CLASS_NAME_SHOW$5 = 'show'; var SELECTOR_TITLE = '.popover-header'; var SELECTOR_CONTENT = '.popover-body'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ var Popover = /*#__PURE__*/function (_Tooltip) { _inheritsLoose(Popover, _Tooltip); function Popover() { return _Tooltip.apply(this, arguments) || this; } var _proto = Popover.prototype; // Overrides _proto.isWithContent = function isWithContent() { return this.getTitle() || this._getContent(); }; _proto.setContent = function setContent() { var tip = this.getTipElement(); // we use append for html objects to maintain js events this.setElementContent(SelectorEngine.findOne(SELECTOR_TITLE, tip), this.getTitle()); var content = this._getContent(); if (typeof content === 'function') { content = content.call(this._element); } this.setElementContent(SelectorEngine.findOne(SELECTOR_CONTENT, tip), content); tip.classList.remove(CLASS_NAME_FADE$3, CLASS_NAME_SHOW$5); } // Private ; _proto._addAttachmentClass = function _addAttachmentClass(attachment) { this.getTipElement().classList.add(CLASS_PREFIX$1 + "-" + this.updateAttachment(attachment)); }; _proto._getContent = function _getContent() { return this._element.getAttribute('data-bs-content') || this.config.content; }; _proto._cleanTipClass = function _cleanTipClass() { var tip = this.getTipElement(); var tabClass = tip.getAttribute('class').match(BSCLS_PREFIX_REGEX$1); if (tabClass !== null && tabClass.length > 0) { tabClass.map(function (token) { return token.trim(); }).forEach(function (tClass) { return tip.classList.remove(tClass); }); } } // Static ; Popover.jQueryInterface = function jQueryInterface(config) { return this.each(function () { var data = Data.getData(this, DATA_KEY$7); var _config = typeof config === 'object' ? config : null; if (!data && /dispose|hide/.test(config)) { return; } if (!data) { data = new Popover(this, _config); Data.setData(this, DATA_KEY$7, data); } if (typeof config === 'string') { if (typeof data[config] === 'undefined') { throw new TypeError("No method named \"" + config + "\""); } data[config](); } }); }; _createClass(Popover, null, [{ key: "Default", // Getters 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$2; } }, { 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 */ defineJQueryPlugin(NAME$7, Popover); /** * ------------------------------------------------------------------------ * Constants * ------------------------------------------------------------------------ */ var NAME$8 = 'scrollspy'; var DATA_KEY$8 = 'bs.scrollspy'; var EVENT_KEY$8 = "." + DATA_KEY$8; var DATA_API_KEY$6 = '.data-api'; var Default$6 = { offset: 10, method: 'auto', target: '' }; var DefaultType$6 = { 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$1 = "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-bs-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_TOGGLE = '.dropdown-toggle'; var METHOD_OFFSET = 'offset'; var METHOD_POSITION = 'position'; /** * ------------------------------------------------------------------------ * Class Definition * ------------------------------------------------------------------------ */ var ScrollSpy = /*#__PURE__*/function (_BaseComponent) { _inheritsLoose(ScrollSpy, _BaseComponent); function ScrollSpy(element, config) { var _this; _this = _BaseComponent.call(this, element) || this; _this._scrollElement = element.tagName === 'BODY' ? window : element; _this._config = _this._getConfig(config); _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; EventHandler.on(_this._scrollElement, EVENT_SCROLL, function () { return _this._process(); }); _this.refresh(); _this._process(); return _this; } // Getters var _proto = ScrollSpy.prototype; // 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; this._offsets = []; this._targets = []; this._scrollHeight = this._getScrollHeight(); var targets = SelectorEngine.find(this._selector); targets.map(function (element) { var targetSelector = getSelectorFromElement(element); var target = targetSelector ? SelectorEngine.findOne(targetSelector) : null; if (target) { var targetBCR = target.getBoundingClientRect(); if (targetBCR.width || targetBCR.height) { 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]); }); }; _proto.dispose = function dispose() { _BaseComponent.prototype.dispose.call(this); EventHandler.off(this._scrollElement, EVENT_KEY$8); this._scrollElement = null; this._config = null; this._selector = null; this._offsets = null; this._targets = null; this._activeTarget = null; this._scrollHeight = null; } // Private ; _proto._getConfig = function _getConfig(config) { config = _extends({}, Default$6, typeof config === 'object' && config ? config : {}); if (typeof config.target !== 'string' && isElement(config.target)) { var id = config.target.id; if (!id) { id = getUID(NAME$8); config.target.id = id; } config.target = "#" + id; } typeCheckConfig(NAME$8, config, DefaultType$6); return config; }; _proto._getScrollTop = function _getScrollTop() { return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop; }; _proto._getScrollHeight = function _getScrollHeight() { return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight); }; _proto._getOffsetHeight = function _getOffsetHeight() { return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height; }; _proto._process = function _process() { var scrollTop = this._getScrollTop() + this._config.offset; var scrollHeight = this._getScrollHeight(); var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight(); if (this._scrollHeight !== scrollHeight) { this.refresh(); } if (scrollTop >= maxScroll) { var target = this._targets[this._targets.length - 1]; if (this._activeTarget !== target) { this._activate(target); } return; } if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) { this._activeTarget = null; this._clear(); 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]); if (isActiveTarget) { this._activate(this._targets[i]); } } }; _proto._activate = function _activate(target) { this._activeTarget = target; this._clear(); var queries = this._selector.split(',').map(function (selector) { return selector + "[data-bs-target=\"" + target + "\"]," + selector + "[href=\"" + target + "\"]"; }); var link = SelectorEngine.findOne(queries.join(',')); if (link.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) { SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE, link.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$2); link.classList.add(CLASS_NAME_ACTIVE$2); } else { // Set triggered link as active link.classList.add(CLASS_NAME_ACTIVE$2); SelectorEngine.parents(link, SELECTOR_NAV_LIST_GROUP).forEach(function (listGroup) { // Set triggered links parents as active // With both