source: imaps-frontend/node_modules/bootstrap/dist/js/bootstrap.bundle.js@ d565449

main
Last change on this file since d565449 was d565449, checked in by stefan toskovski <stefantoska84@…>, 4 weeks ago

Update repo after prototype presentation
  • Property mode set to 100644
File size: 202.9 KB
RevLine 
[d565449]1/*!
2 * Bootstrap v5.3.3 (https://getbootstrap.com/)
3 * Copyright 2011-2024 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
4 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
5 */
6(function (global, factory) {
7 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
8 typeof define === 'function' && define.amd ? define(factory) :
9 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.bootstrap = factory());
10})(this, (function () { 'use strict';
11
12 /**
13 * --------------------------------------------------------------------------
14 * Bootstrap dom/data.js
15 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
16 * --------------------------------------------------------------------------
17 */
18
19 /**
20 * Constants
21 */
22
23 const elementMap = new Map();
24 const Data = {
25 set(element, key, instance) {
26 if (!elementMap.has(element)) {
27 elementMap.set(element, new Map());
28 }
29 const instanceMap = elementMap.get(element);
30
31 // make it clear we only want one instance per element
32 // can be removed later when multiple key/instances are fine to be used
33 if (!instanceMap.has(key) && instanceMap.size !== 0) {
34 // eslint-disable-next-line no-console
35 console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);
36 return;
37 }
38 instanceMap.set(key, instance);
39 },
40 get(element, key) {
41 if (elementMap.has(element)) {
42 return elementMap.get(element).get(key) || null;
43 }
44 return null;
45 },
46 remove(element, key) {
47 if (!elementMap.has(element)) {
48 return;
49 }
50 const instanceMap = elementMap.get(element);
51 instanceMap.delete(key);
52
53 // free up element references if there are no instances left for an element
54 if (instanceMap.size === 0) {
55 elementMap.delete(element);
56 }
57 }
58 };
59
60 /**
61 * --------------------------------------------------------------------------
62 * Bootstrap util/index.js
63 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
64 * --------------------------------------------------------------------------
65 */
66
67 const MAX_UID = 1000000;
68 const MILLISECONDS_MULTIPLIER = 1000;
69 const TRANSITION_END = 'transitionend';
70
71 /**
72 * Properly escape IDs selectors to handle weird IDs
73 * @param {string} selector
74 * @returns {string}
75 */
76 const parseSelector = selector => {
77 if (selector && window.CSS && window.CSS.escape) {
78 // document.querySelector needs escaping to handle IDs (html5+) containing for instance /
79 selector = selector.replace(/#([^\s"#']+)/g, (match, id) => `#${CSS.escape(id)}`);
80 }
81 return selector;
82 };
83
84 // Shout-out Angus Croll (https://goo.gl/pxwQGp)
85 const toType = object => {
86 if (object === null || object === undefined) {
87 return `${object}`;
88 }
89 return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase();
90 };
91
92 /**
93 * Public Util API
94 */
95
96 const getUID = prefix => {
97 do {
98 prefix += Math.floor(Math.random() * MAX_UID);
99 } while (document.getElementById(prefix));
100 return prefix;
101 };
102 const getTransitionDurationFromElement = element => {
103 if (!element) {
104 return 0;
105 }
106
107 // Get transition-duration of the element
108 let {
109 transitionDuration,
110 transitionDelay
111 } = window.getComputedStyle(element);
112 const floatTransitionDuration = Number.parseFloat(transitionDuration);
113 const floatTransitionDelay = Number.parseFloat(transitionDelay);
114
115 // Return 0 if element or transition duration is not found
116 if (!floatTransitionDuration && !floatTransitionDelay) {
117 return 0;
118 }
119
120 // If multiple durations are defined, take the first
121 transitionDuration = transitionDuration.split(',')[0];
122 transitionDelay = transitionDelay.split(',')[0];
123 return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
124 };
125 const triggerTransitionEnd = element => {
126 element.dispatchEvent(new Event(TRANSITION_END));
127 };
128 const isElement$1 = object => {
129 if (!object || typeof object !== 'object') {
130 return false;
131 }
132 if (typeof object.jquery !== 'undefined') {
133 object = object[0];
134 }
135 return typeof object.nodeType !== 'undefined';
136 };
137 const getElement = object => {
138 // it's a jQuery object or a node element
139 if (isElement$1(object)) {
140 return object.jquery ? object[0] : object;
141 }
142 if (typeof object === 'string' && object.length > 0) {
143 return document.querySelector(parseSelector(object));
144 }
145 return null;
146 };
147 const isVisible = element => {
148 if (!isElement$1(element) || element.getClientRects().length === 0) {
149 return false;
150 }
151 const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible';
152 // Handle `details` element as its content may falsie appear visible when it is closed
153 const closedDetails = element.closest('details:not([open])');
154 if (!closedDetails) {
155 return elementIsVisible;
156 }
157 if (closedDetails !== element) {
158 const summary = element.closest('summary');
159 if (summary && summary.parentNode !== closedDetails) {
160 return false;
161 }
162 if (summary === null) {
163 return false;
164 }
165 }
166 return elementIsVisible;
167 };
168 const isDisabled = element => {
169 if (!element || element.nodeType !== Node.ELEMENT_NODE) {
170 return true;
171 }
172 if (element.classList.contains('disabled')) {
173 return true;
174 }
175 if (typeof element.disabled !== 'undefined') {
176 return element.disabled;
177 }
178 return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
179 };
180 const findShadowRoot = element => {
181 if (!document.documentElement.attachShadow) {
182 return null;
183 }
184
185 // Can find the shadow root otherwise it'll return the document
186 if (typeof element.getRootNode === 'function') {
187 const root = element.getRootNode();
188 return root instanceof ShadowRoot ? root : null;
189 }
190 if (element instanceof ShadowRoot) {
191 return element;
192 }
193
194 // when we don't find a shadow root
195 if (!element.parentNode) {
196 return null;
197 }
198 return findShadowRoot(element.parentNode);
199 };
200 const noop = () => {};
201
202 /**
203 * Trick to restart an element's animation
204 *
205 * @param {HTMLElement} element
206 * @return void
207 *
208 * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
209 */
210 const reflow = element => {
211 element.offsetHeight; // eslint-disable-line no-unused-expressions
212 };
213 const getjQuery = () => {
214 if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
215 return window.jQuery;
216 }
217 return null;
218 };
219 const DOMContentLoadedCallbacks = [];
220 const onDOMContentLoaded = callback => {
221 if (document.readyState === 'loading') {
222 // add listener on the first call when the document is in loading state
223 if (!DOMContentLoadedCallbacks.length) {
224 document.addEventListener('DOMContentLoaded', () => {
225 for (const callback of DOMContentLoadedCallbacks) {
226 callback();
227 }
228 });
229 }
230 DOMContentLoadedCallbacks.push(callback);
231 } else {
232 callback();
233 }
234 };
235 const isRTL = () => document.documentElement.dir === 'rtl';
236 const defineJQueryPlugin = plugin => {
237 onDOMContentLoaded(() => {
238 const $ = getjQuery();
239 /* istanbul ignore if */
240 if ($) {
241 const name = plugin.NAME;
242 const JQUERY_NO_CONFLICT = $.fn[name];
243 $.fn[name] = plugin.jQueryInterface;
244 $.fn[name].Constructor = plugin;
245 $.fn[name].noConflict = () => {
246 $.fn[name] = JQUERY_NO_CONFLICT;
247 return plugin.jQueryInterface;
248 };
249 }
250 });
251 };
252 const execute = (possibleCallback, args = [], defaultValue = possibleCallback) => {
253 return typeof possibleCallback === 'function' ? possibleCallback(...args) : defaultValue;
254 };
255 const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
256 if (!waitForTransition) {
257 execute(callback);
258 return;
259 }
260 const durationPadding = 5;
261 const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
262 let called = false;
263 const handler = ({
264 target
265 }) => {
266 if (target !== transitionElement) {
267 return;
268 }
269 called = true;
270 transitionElement.removeEventListener(TRANSITION_END, handler);
271 execute(callback);
272 };
273 transitionElement.addEventListener(TRANSITION_END, handler);
274 setTimeout(() => {
275 if (!called) {
276 triggerTransitionEnd(transitionElement);
277 }
278 }, emulatedDuration);
279 };
280
281 /**
282 * Return the previous/next element of a list.
283 *
284 * @param {array} list The list of elements
285 * @param activeElement The active element
286 * @param shouldGetNext Choose to get next or previous element
287 * @param isCycleAllowed
288 * @return {Element|elem} The proper element
289 */
290 const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
291 const listLength = list.length;
292 let index = list.indexOf(activeElement);
293
294 // if the element does not exist in the list return an element
295 // depending on the direction and if cycle is allowed
296 if (index === -1) {
297 return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];
298 }
299 index += shouldGetNext ? 1 : -1;
300 if (isCycleAllowed) {
301 index = (index + listLength) % listLength;
302 }
303 return list[Math.max(0, Math.min(index, listLength - 1))];
304 };
305
306 /**
307 * --------------------------------------------------------------------------
308 * Bootstrap dom/event-handler.js
309 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
310 * --------------------------------------------------------------------------
311 */
312
313
314 /**
315 * Constants
316 */
317
318 const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
319 const stripNameRegex = /\..*/;
320 const stripUidRegex = /::\d+$/;
321 const eventRegistry = {}; // Events storage
322 let uidEvent = 1;
323 const customEvents = {
324 mouseenter: 'mouseover',
325 mouseleave: 'mouseout'
326 };
327 const nativeEvents = new Set(['click', 'dblclick', 'mouseup', 'mousedown', 'contextmenu', 'mousewheel', 'DOMMouseScroll', 'mouseover', 'mouseout', 'mousemove', 'selectstart', 'selectend', 'keydown', 'keypress', 'keyup', 'orientationchange', 'touchstart', 'touchmove', 'touchend', 'touchcancel', 'pointerdown', 'pointermove', 'pointerup', 'pointerleave', 'pointercancel', 'gesturestart', 'gesturechange', 'gestureend', 'focus', 'blur', 'change', 'reset', 'select', 'submit', 'focusin', 'focusout', 'load', 'unload', 'beforeunload', 'resize', 'move', 'DOMContentLoaded', 'readystatechange', 'error', 'abort', 'scroll']);
328
329 /**
330 * Private methods
331 */
332
333 function makeEventUid(element, uid) {
334 return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
335 }
336 function getElementEvents(element) {
337 const uid = makeEventUid(element);
338 element.uidEvent = uid;
339 eventRegistry[uid] = eventRegistry[uid] || {};
340 return eventRegistry[uid];
341 }
342 function bootstrapHandler(element, fn) {
343 return function handler(event) {
344 hydrateObj(event, {
345 delegateTarget: element
346 });
347 if (handler.oneOff) {
348 EventHandler.off(element, event.type, fn);
349 }
350 return fn.apply(element, [event]);
351 };
352 }
353 function bootstrapDelegationHandler(element, selector, fn) {
354 return function handler(event) {
355 const domElements = element.querySelectorAll(selector);
356 for (let {
357 target
358 } = event; target && target !== this; target = target.parentNode) {
359 for (const domElement of domElements) {
360 if (domElement !== target) {
361 continue;
362 }
363 hydrateObj(event, {
364 delegateTarget: target
365 });
366 if (handler.oneOff) {
367 EventHandler.off(element, event.type, selector, fn);
368 }
369 return fn.apply(target, [event]);
370 }
371 }
372 };
373 }
374 function findHandler(events, callable, delegationSelector = null) {
375 return Object.values(events).find(event => event.callable === callable && event.delegationSelector === delegationSelector);
376 }
377 function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
378 const isDelegated = typeof handler === 'string';
379 // TODO: tooltip passes `false` instead of selector, so we need to check
380 const callable = isDelegated ? delegationFunction : handler || delegationFunction;
381 let typeEvent = getTypeEvent(originalTypeEvent);
382 if (!nativeEvents.has(typeEvent)) {
383 typeEvent = originalTypeEvent;
384 }
385 return [isDelegated, callable, typeEvent];
386 }
387 function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
388 if (typeof originalTypeEvent !== 'string' || !element) {
389 return;
390 }
391 let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
392
393 // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
394 // this prevents the handler from being dispatched the same way as mouseover or mouseout does
395 if (originalTypeEvent in customEvents) {
396 const wrapFunction = fn => {
397 return function (event) {
398 if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
399 return fn.call(this, event);
400 }
401 };
402 };
403 callable = wrapFunction(callable);
404 }
405 const events = getElementEvents(element);
406 const handlers = events[typeEvent] || (events[typeEvent] = {});
407 const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
408 if (previousFunction) {
409 previousFunction.oneOff = previousFunction.oneOff && oneOff;
410 return;
411 }
412 const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''));
413 const fn = isDelegated ? bootstrapDelegationHandler(element, handler, callable) : bootstrapHandler(element, callable);
414 fn.delegationSelector = isDelegated ? handler : null;
415 fn.callable = callable;
416 fn.oneOff = oneOff;
417 fn.uidEvent = uid;
418 handlers[uid] = fn;
419 element.addEventListener(typeEvent, fn, isDelegated);
420 }
421 function removeHandler(element, events, typeEvent, handler, delegationSelector) {
422 const fn = findHandler(events[typeEvent], handler, delegationSelector);
423 if (!fn) {
424 return;
425 }
426 element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
427 delete events[typeEvent][fn.uidEvent];
428 }
429 function removeNamespacedHandlers(element, events, typeEvent, namespace) {
430 const storeElementEvent = events[typeEvent] || {};
431 for (const [handlerKey, event] of Object.entries(storeElementEvent)) {
432 if (handlerKey.includes(namespace)) {
433 removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
434 }
435 }
436 }
437 function getTypeEvent(event) {
438 // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
439 event = event.replace(stripNameRegex, '');
440 return customEvents[event] || event;
441 }
442 const EventHandler = {
443 on(element, event, handler, delegationFunction) {
444 addHandler(element, event, handler, delegationFunction, false);
445 },
446 one(element, event, handler, delegationFunction) {
447 addHandler(element, event, handler, delegationFunction, true);
448 },
449 off(element, originalTypeEvent, handler, delegationFunction) {
450 if (typeof originalTypeEvent !== 'string' || !element) {
451 return;
452 }
453 const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
454 const inNamespace = typeEvent !== originalTypeEvent;
455 const events = getElementEvents(element);
456 const storeElementEvent = events[typeEvent] || {};
457 const isNamespace = originalTypeEvent.startsWith('.');
458 if (typeof callable !== 'undefined') {
459 // Simplest case: handler is passed, remove that listener ONLY.
460 if (!Object.keys(storeElementEvent).length) {
461 return;
462 }
463 removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
464 return;
465 }
466 if (isNamespace) {
467 for (const elementEvent of Object.keys(events)) {
468 removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
469 }
470 }
471 for (const [keyHandlers, event] of Object.entries(storeElementEvent)) {
472 const handlerKey = keyHandlers.replace(stripUidRegex, '');
473 if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
474 removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
475 }
476 }
477 },
478 trigger(element, event, args) {
479 if (typeof event !== 'string' || !element) {
480 return null;
481 }
482 const $ = getjQuery();
483 const typeEvent = getTypeEvent(event);
484 const inNamespace = event !== typeEvent;
485 let jQueryEvent = null;
486 let bubbles = true;
487 let nativeDispatch = true;
488 let defaultPrevented = false;
489 if (inNamespace && $) {
490 jQueryEvent = $.Event(event, args);
491 $(element).trigger(jQueryEvent);
492 bubbles = !jQueryEvent.isPropagationStopped();
493 nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
494 defaultPrevented = jQueryEvent.isDefaultPrevented();
495 }
496 const evt = hydrateObj(new Event(event, {
497 bubbles,
498 cancelable: true
499 }), args);
500 if (defaultPrevented) {
501 evt.preventDefault();
502 }
503 if (nativeDispatch) {
504 element.dispatchEvent(evt);
505 }
506 if (evt.defaultPrevented && jQueryEvent) {
507 jQueryEvent.preventDefault();
508 }
509 return evt;
510 }
511 };
512 function hydrateObj(obj, meta = {}) {
513 for (const [key, value] of Object.entries(meta)) {
514 try {
515 obj[key] = value;
516 } catch (_unused) {
517 Object.defineProperty(obj, key, {
518 configurable: true,
519 get() {
520 return value;
521 }
522 });
523 }
524 }
525 return obj;
526 }
527
528 /**
529 * --------------------------------------------------------------------------
530 * Bootstrap dom/manipulator.js
531 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
532 * --------------------------------------------------------------------------
533 */
534
535 function normalizeData(value) {
536 if (value === 'true') {
537 return true;
538 }
539 if (value === 'false') {
540 return false;
541 }
542 if (value === Number(value).toString()) {
543 return Number(value);
544 }
545 if (value === '' || value === 'null') {
546 return null;
547 }
548 if (typeof value !== 'string') {
549 return value;
550 }
551 try {
552 return JSON.parse(decodeURIComponent(value));
553 } catch (_unused) {
554 return value;
555 }
556 }
557 function normalizeDataKey(key) {
558 return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`);
559 }
560 const Manipulator = {
561 setDataAttribute(element, key, value) {
562 element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);
563 },
564 removeDataAttribute(element, key) {
565 element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);
566 },
567 getDataAttributes(element) {
568 if (!element) {
569 return {};
570 }
571 const attributes = {};
572 const bsKeys = Object.keys(element.dataset).filter(key => key.startsWith('bs') && !key.startsWith('bsConfig'));
573 for (const key of bsKeys) {
574 let pureKey = key.replace(/^bs/, '');
575 pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
576 attributes[pureKey] = normalizeData(element.dataset[key]);
577 }
578 return attributes;
579 },
580 getDataAttribute(element, key) {
581 return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
582 }
583 };
584
585 /**
586 * --------------------------------------------------------------------------
587 * Bootstrap util/config.js
588 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
589 * --------------------------------------------------------------------------
590 */
591
592
593 /**
594 * Class definition
595 */
596
597 class Config {
598 // Getters
599 static get Default() {
600 return {};
601 }
602 static get DefaultType() {
603 return {};
604 }
605 static get NAME() {
606 throw new Error('You have to implement the static method "NAME", for each component!');
607 }
608 _getConfig(config) {
609 config = this._mergeConfigObj(config);
610 config = this._configAfterMerge(config);
611 this._typeCheckConfig(config);
612 return config;
613 }
614 _configAfterMerge(config) {
615 return config;
616 }
617 _mergeConfigObj(config, element) {
618 const jsonConfig = isElement$1(element) ? Manipulator.getDataAttribute(element, 'config') : {}; // try to parse
619
620 return {
621 ...this.constructor.Default,
622 ...(typeof jsonConfig === 'object' ? jsonConfig : {}),
623 ...(isElement$1(element) ? Manipulator.getDataAttributes(element) : {}),
624 ...(typeof config === 'object' ? config : {})
625 };
626 }
627 _typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
628 for (const [property, expectedTypes] of Object.entries(configTypes)) {
629 const value = config[property];
630 const valueType = isElement$1(value) ? 'element' : toType(value);
631 if (!new RegExp(expectedTypes).test(valueType)) {
632 throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`);
633 }
634 }
635 }
636 }
637
638 /**
639 * --------------------------------------------------------------------------
640 * Bootstrap base-component.js
641 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
642 * --------------------------------------------------------------------------
643 */
644
645
646 /**
647 * Constants
648 */
649
650 const VERSION = '5.3.3';
651
652 /**
653 * Class definition
654 */
655
656 class BaseComponent extends Config {
657 constructor(element, config) {
658 super();
659 element = getElement(element);
660 if (!element) {
661 return;
662 }
663 this._element = element;
664 this._config = this._getConfig(config);
665 Data.set(this._element, this.constructor.DATA_KEY, this);
666 }
667
668 // Public
669 dispose() {
670 Data.remove(this._element, this.constructor.DATA_KEY);
671 EventHandler.off(this._element, this.constructor.EVENT_KEY);
672 for (const propertyName of Object.getOwnPropertyNames(this)) {
673 this[propertyName] = null;
674 }
675 }
676 _queueCallback(callback, element, isAnimated = true) {
677 executeAfterTransition(callback, element, isAnimated);
678 }
679 _getConfig(config) {
680 config = this._mergeConfigObj(config, this._element);
681 config = this._configAfterMerge(config);
682 this._typeCheckConfig(config);
683 return config;
684 }
685
686 // Static
687 static getInstance(element) {
688 return Data.get(getElement(element), this.DATA_KEY);
689 }
690 static getOrCreateInstance(element, config = {}) {
691 return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);
692 }
693 static get VERSION() {
694 return VERSION;
695 }
696 static get DATA_KEY() {
697 return `bs.${this.NAME}`;
698 }
699 static get EVENT_KEY() {
700 return `.${this.DATA_KEY}`;
701 }
702 static eventName(name) {
703 return `${name}${this.EVENT_KEY}`;
704 }
705 }
706
707 /**
708 * --------------------------------------------------------------------------
709 * Bootstrap dom/selector-engine.js
710 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
711 * --------------------------------------------------------------------------
712 */
713
714 const getSelector = element => {
715 let selector = element.getAttribute('data-bs-target');
716 if (!selector || selector === '#') {
717 let hrefAttribute = element.getAttribute('href');
718
719 // The only valid content that could double as a selector are IDs or classes,
720 // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
721 // `document.querySelector` will rightfully complain it is invalid.
722 // See https://github.com/twbs/bootstrap/issues/32273
723 if (!hrefAttribute || !hrefAttribute.includes('#') && !hrefAttribute.startsWith('.')) {
724 return null;
725 }
726
727 // Just in case some CMS puts out a full URL with the anchor appended
728 if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) {
729 hrefAttribute = `#${hrefAttribute.split('#')[1]}`;
730 }
731 selector = hrefAttribute && hrefAttribute !== '#' ? hrefAttribute.trim() : null;
732 }
733 return selector ? selector.split(',').map(sel => parseSelector(sel)).join(',') : null;
734 };
735 const SelectorEngine = {
736 find(selector, element = document.documentElement) {
737 return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
738 },
739 findOne(selector, element = document.documentElement) {
740 return Element.prototype.querySelector.call(element, selector);
741 },
742 children(element, selector) {
743 return [].concat(...element.children).filter(child => child.matches(selector));
744 },
745 parents(element, selector) {
746 const parents = [];
747 let ancestor = element.parentNode.closest(selector);
748 while (ancestor) {
749 parents.push(ancestor);
750 ancestor = ancestor.parentNode.closest(selector);
751 }
752 return parents;
753 },
754 prev(element, selector) {
755 let previous = element.previousElementSibling;
756 while (previous) {
757 if (previous.matches(selector)) {
758 return [previous];
759 }
760 previous = previous.previousElementSibling;
761 }
762 return [];
763 },
764 // TODO: this is now unused; remove later along with prev()
765 next(element, selector) {
766 let next = element.nextElementSibling;
767 while (next) {
768 if (next.matches(selector)) {
769 return [next];
770 }
771 next = next.nextElementSibling;
772 }
773 return [];
774 },
775 focusableChildren(element) {
776 const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(selector => `${selector}:not([tabindex^="-"])`).join(',');
777 return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el));
778 },
779 getSelectorFromElement(element) {
780 const selector = getSelector(element);
781 if (selector) {
782 return SelectorEngine.findOne(selector) ? selector : null;
783 }
784 return null;
785 },
786 getElementFromSelector(element) {
787 const selector = getSelector(element);
788 return selector ? SelectorEngine.findOne(selector) : null;
789 },
790 getMultipleElementsFromSelector(element) {
791 const selector = getSelector(element);
792 return selector ? SelectorEngine.find(selector) : [];
793 }
794 };
795
796 /**
797 * --------------------------------------------------------------------------
798 * Bootstrap util/component-functions.js
799 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
800 * --------------------------------------------------------------------------
801 */
802
803 const enableDismissTrigger = (component, method = 'hide') => {
804 const clickEvent = `click.dismiss${component.EVENT_KEY}`;
805 const name = component.NAME;
806 EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) {
807 if (['A', 'AREA'].includes(this.tagName)) {
808 event.preventDefault();
809 }
810 if (isDisabled(this)) {
811 return;
812 }
813 const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`);
814 const instance = component.getOrCreateInstance(target);
815
816 // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
817 instance[method]();
818 });
819 };
820
821 /**
822 * --------------------------------------------------------------------------
823 * Bootstrap alert.js
824 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
825 * --------------------------------------------------------------------------
826 */
827
828
829 /**
830 * Constants
831 */
832
833 const NAME$f = 'alert';
834 const DATA_KEY$a = 'bs.alert';
835 const EVENT_KEY$b = `.${DATA_KEY$a}`;
836 const EVENT_CLOSE = `close${EVENT_KEY$b}`;
837 const EVENT_CLOSED = `closed${EVENT_KEY$b}`;
838 const CLASS_NAME_FADE$5 = 'fade';
839 const CLASS_NAME_SHOW$8 = 'show';
840
841 /**
842 * Class definition
843 */
844
845 class Alert extends BaseComponent {
846 // Getters
847 static get NAME() {
848 return NAME$f;
849 }
850
851 // Public
852 close() {
853 const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
854 if (closeEvent.defaultPrevented) {
855 return;
856 }
857 this._element.classList.remove(CLASS_NAME_SHOW$8);
858 const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
859 this._queueCallback(() => this._destroyElement(), this._element, isAnimated);
860 }
861
862 // Private
863 _destroyElement() {
864 this._element.remove();
865 EventHandler.trigger(this._element, EVENT_CLOSED);
866 this.dispose();
867 }
868
869 // Static
870 static jQueryInterface(config) {
871 return this.each(function () {
872 const data = Alert.getOrCreateInstance(this);
873 if (typeof config !== 'string') {
874 return;
875 }
876 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
877 throw new TypeError(`No method named "${config}"`);
878 }
879 data[config](this);
880 });
881 }
882 }
883
884 /**
885 * Data API implementation
886 */
887
888 enableDismissTrigger(Alert, 'close');
889
890 /**
891 * jQuery
892 */
893
894 defineJQueryPlugin(Alert);
895
896 /**
897 * --------------------------------------------------------------------------
898 * Bootstrap button.js
899 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
900 * --------------------------------------------------------------------------
901 */
902
903
904 /**
905 * Constants
906 */
907
908 const NAME$e = 'button';
909 const DATA_KEY$9 = 'bs.button';
910 const EVENT_KEY$a = `.${DATA_KEY$9}`;
911 const DATA_API_KEY$6 = '.data-api';
912 const CLASS_NAME_ACTIVE$3 = 'active';
913 const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
914 const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`;
915
916 /**
917 * Class definition
918 */
919
920 class Button extends BaseComponent {
921 // Getters
922 static get NAME() {
923 return NAME$e;
924 }
925
926 // Public
927 toggle() {
928 // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
929 this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3));
930 }
931
932 // Static
933 static jQueryInterface(config) {
934 return this.each(function () {
935 const data = Button.getOrCreateInstance(this);
936 if (config === 'toggle') {
937 data[config]();
938 }
939 });
940 }
941 }
942
943 /**
944 * Data API implementation
945 */
946
947 EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => {
948 event.preventDefault();
949 const button = event.target.closest(SELECTOR_DATA_TOGGLE$5);
950 const data = Button.getOrCreateInstance(button);
951 data.toggle();
952 });
953
954 /**
955 * jQuery
956 */
957
958 defineJQueryPlugin(Button);
959
960 /**
961 * --------------------------------------------------------------------------
962 * Bootstrap util/swipe.js
963 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
964 * --------------------------------------------------------------------------
965 */
966
967
968 /**
969 * Constants
970 */
971
972 const NAME$d = 'swipe';
973 const EVENT_KEY$9 = '.bs.swipe';
974 const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$9}`;
975 const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$9}`;
976 const EVENT_TOUCHEND = `touchend${EVENT_KEY$9}`;
977 const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$9}`;
978 const EVENT_POINTERUP = `pointerup${EVENT_KEY$9}`;
979 const POINTER_TYPE_TOUCH = 'touch';
980 const POINTER_TYPE_PEN = 'pen';
981 const CLASS_NAME_POINTER_EVENT = 'pointer-event';
982 const SWIPE_THRESHOLD = 40;
983 const Default$c = {
984 endCallback: null,
985 leftCallback: null,
986 rightCallback: null
987 };
988 const DefaultType$c = {
989 endCallback: '(function|null)',
990 leftCallback: '(function|null)',
991 rightCallback: '(function|null)'
992 };
993
994 /**
995 * Class definition
996 */
997
998 class Swipe extends Config {
999 constructor(element, config) {
1000 super();
1001 this._element = element;
1002 if (!element || !Swipe.isSupported()) {
1003 return;
1004 }
1005 this._config = this._getConfig(config);
1006 this._deltaX = 0;
1007 this._supportPointerEvents = Boolean(window.PointerEvent);
1008 this._initEvents();
1009 }
1010
1011 // Getters
1012 static get Default() {
1013 return Default$c;
1014 }
1015 static get DefaultType() {
1016 return DefaultType$c;
1017 }
1018 static get NAME() {
1019 return NAME$d;
1020 }
1021
1022 // Public
1023 dispose() {
1024 EventHandler.off(this._element, EVENT_KEY$9);
1025 }
1026
1027 // Private
1028 _start(event) {
1029 if (!this._supportPointerEvents) {
1030 this._deltaX = event.touches[0].clientX;
1031 return;
1032 }
1033 if (this._eventIsPointerPenTouch(event)) {
1034 this._deltaX = event.clientX;
1035 }
1036 }
1037 _end(event) {
1038 if (this._eventIsPointerPenTouch(event)) {
1039 this._deltaX = event.clientX - this._deltaX;
1040 }
1041 this._handleSwipe();
1042 execute(this._config.endCallback);
1043 }
1044 _move(event) {
1045 this._deltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this._deltaX;
1046 }
1047 _handleSwipe() {
1048 const absDeltaX = Math.abs(this._deltaX);
1049 if (absDeltaX <= SWIPE_THRESHOLD) {
1050 return;
1051 }
1052 const direction = absDeltaX / this._deltaX;
1053 this._deltaX = 0;
1054 if (!direction) {
1055 return;
1056 }
1057 execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback);
1058 }
1059 _initEvents() {
1060 if (this._supportPointerEvents) {
1061 EventHandler.on(this._element, EVENT_POINTERDOWN, event => this._start(event));
1062 EventHandler.on(this._element, EVENT_POINTERUP, event => this._end(event));
1063 this._element.classList.add(CLASS_NAME_POINTER_EVENT);
1064 } else {
1065 EventHandler.on(this._element, EVENT_TOUCHSTART, event => this._start(event));
1066 EventHandler.on(this._element, EVENT_TOUCHMOVE, event => this._move(event));
1067 EventHandler.on(this._element, EVENT_TOUCHEND, event => this._end(event));
1068 }
1069 }
1070 _eventIsPointerPenTouch(event) {
1071 return this._supportPointerEvents && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH);
1072 }
1073
1074 // Static
1075 static isSupported() {
1076 return 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
1077 }
1078 }
1079
1080 /**
1081 * --------------------------------------------------------------------------
1082 * Bootstrap carousel.js
1083 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1084 * --------------------------------------------------------------------------
1085 */
1086
1087
1088 /**
1089 * Constants
1090 */
1091
1092 const NAME$c = 'carousel';
1093 const DATA_KEY$8 = 'bs.carousel';
1094 const EVENT_KEY$8 = `.${DATA_KEY$8}`;
1095 const DATA_API_KEY$5 = '.data-api';
1096 const ARROW_LEFT_KEY$1 = 'ArrowLeft';
1097 const ARROW_RIGHT_KEY$1 = 'ArrowRight';
1098 const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
1099
1100 const ORDER_NEXT = 'next';
1101 const ORDER_PREV = 'prev';
1102 const DIRECTION_LEFT = 'left';
1103 const DIRECTION_RIGHT = 'right';
1104 const EVENT_SLIDE = `slide${EVENT_KEY$8}`;
1105 const EVENT_SLID = `slid${EVENT_KEY$8}`;
1106 const EVENT_KEYDOWN$1 = `keydown${EVENT_KEY$8}`;
1107 const EVENT_MOUSEENTER$1 = `mouseenter${EVENT_KEY$8}`;
1108 const EVENT_MOUSELEAVE$1 = `mouseleave${EVENT_KEY$8}`;
1109 const EVENT_DRAG_START = `dragstart${EVENT_KEY$8}`;
1110 const EVENT_LOAD_DATA_API$3 = `load${EVENT_KEY$8}${DATA_API_KEY$5}`;
1111 const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`;
1112 const CLASS_NAME_CAROUSEL = 'carousel';
1113 const CLASS_NAME_ACTIVE$2 = 'active';
1114 const CLASS_NAME_SLIDE = 'slide';
1115 const CLASS_NAME_END = 'carousel-item-end';
1116 const CLASS_NAME_START = 'carousel-item-start';
1117 const CLASS_NAME_NEXT = 'carousel-item-next';
1118 const CLASS_NAME_PREV = 'carousel-item-prev';
1119 const SELECTOR_ACTIVE = '.active';
1120 const SELECTOR_ITEM = '.carousel-item';
1121 const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_ITEM;
1122 const SELECTOR_ITEM_IMG = '.carousel-item img';
1123 const SELECTOR_INDICATORS = '.carousel-indicators';
1124 const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]';
1125 const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
1126 const KEY_TO_DIRECTION = {
1127 [ARROW_LEFT_KEY$1]: DIRECTION_RIGHT,
1128 [ARROW_RIGHT_KEY$1]: DIRECTION_LEFT
1129 };
1130 const Default$b = {
1131 interval: 5000,
1132 keyboard: true,
1133 pause: 'hover',
1134 ride: false,
1135 touch: true,
1136 wrap: true
1137 };
1138 const DefaultType$b = {
1139 interval: '(number|boolean)',
1140 // TODO:v6 remove boolean support
1141 keyboard: 'boolean',
1142 pause: '(string|boolean)',
1143 ride: '(boolean|string)',
1144 touch: 'boolean',
1145 wrap: 'boolean'
1146 };
1147
1148 /**
1149 * Class definition
1150 */
1151
1152 class Carousel extends BaseComponent {
1153 constructor(element, config) {
1154 super(element, config);
1155 this._interval = null;
1156 this._activeElement = null;
1157 this._isSliding = false;
1158 this.touchTimeout = null;
1159 this._swipeHelper = null;
1160 this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
1161 this._addEventListeners();
1162 if (this._config.ride === CLASS_NAME_CAROUSEL) {
1163 this.cycle();
1164 }
1165 }
1166
1167 // Getters
1168 static get Default() {
1169 return Default$b;
1170 }
1171 static get DefaultType() {
1172 return DefaultType$b;
1173 }
1174 static get NAME() {
1175 return NAME$c;
1176 }
1177
1178 // Public
1179 next() {
1180 this._slide(ORDER_NEXT);
1181 }
1182 nextWhenVisible() {
1183 // FIXME TODO use `document.visibilityState`
1184 // Don't call next when the page isn't visible
1185 // or the carousel or its parent isn't visible
1186 if (!document.hidden && isVisible(this._element)) {
1187 this.next();
1188 }
1189 }
1190 prev() {
1191 this._slide(ORDER_PREV);
1192 }
1193 pause() {
1194 if (this._isSliding) {
1195 triggerTransitionEnd(this._element);
1196 }
1197 this._clearInterval();
1198 }
1199 cycle() {
1200 this._clearInterval();
1201 this._updateInterval();
1202 this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);
1203 }
1204 _maybeEnableCycle() {
1205 if (!this._config.ride) {
1206 return;
1207 }
1208 if (this._isSliding) {
1209 EventHandler.one(this._element, EVENT_SLID, () => this.cycle());
1210 return;
1211 }
1212 this.cycle();
1213 }
1214 to(index) {
1215 const items = this._getItems();
1216 if (index > items.length - 1 || index < 0) {
1217 return;
1218 }
1219 if (this._isSliding) {
1220 EventHandler.one(this._element, EVENT_SLID, () => this.to(index));
1221 return;
1222 }
1223 const activeIndex = this._getItemIndex(this._getActive());
1224 if (activeIndex === index) {
1225 return;
1226 }
1227 const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
1228 this._slide(order, items[index]);
1229 }
1230 dispose() {
1231 if (this._swipeHelper) {
1232 this._swipeHelper.dispose();
1233 }
1234 super.dispose();
1235 }
1236
1237 // Private
1238 _configAfterMerge(config) {
1239 config.defaultInterval = config.interval;
1240 return config;
1241 }
1242 _addEventListeners() {
1243 if (this._config.keyboard) {
1244 EventHandler.on(this._element, EVENT_KEYDOWN$1, event => this._keydown(event));
1245 }
1246 if (this._config.pause === 'hover') {
1247 EventHandler.on(this._element, EVENT_MOUSEENTER$1, () => this.pause());
1248 EventHandler.on(this._element, EVENT_MOUSELEAVE$1, () => this._maybeEnableCycle());
1249 }
1250 if (this._config.touch && Swipe.isSupported()) {
1251 this._addTouchEventListeners();
1252 }
1253 }
1254 _addTouchEventListeners() {
1255 for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {
1256 EventHandler.on(img, EVENT_DRAG_START, event => event.preventDefault());
1257 }
1258 const endCallBack = () => {
1259 if (this._config.pause !== 'hover') {
1260 return;
1261 }
1262
1263 // If it's a touch-enabled device, mouseenter/leave are fired as
1264 // part of the mouse compatibility events on first tap - the carousel
1265 // would stop cycling until user tapped out of it;
1266 // here, we listen for touchend, explicitly pause the carousel
1267 // (as if it's the second time we tap on it, mouseenter compat event
1268 // is NOT fired) and after a timeout (to allow for mouse compatibility
1269 // events to fire) we explicitly restart cycling
1270
1271 this.pause();
1272 if (this.touchTimeout) {
1273 clearTimeout(this.touchTimeout);
1274 }
1275 this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval);
1276 };
1277 const swipeConfig = {
1278 leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
1279 rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
1280 endCallback: endCallBack
1281 };
1282 this._swipeHelper = new Swipe(this._element, swipeConfig);
1283 }
1284 _keydown(event) {
1285 if (/input|textarea/i.test(event.target.tagName)) {
1286 return;
1287 }
1288 const direction = KEY_TO_DIRECTION[event.key];
1289 if (direction) {
1290 event.preventDefault();
1291 this._slide(this._directionToOrder(direction));
1292 }
1293 }
1294 _getItemIndex(element) {
1295 return this._getItems().indexOf(element);
1296 }
1297 _setActiveIndicatorElement(index) {
1298 if (!this._indicatorsElement) {
1299 return;
1300 }
1301 const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
1302 activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);
1303 activeIndicator.removeAttribute('aria-current');
1304 const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement);
1305 if (newActiveIndicator) {
1306 newActiveIndicator.classList.add(CLASS_NAME_ACTIVE$2);
1307 newActiveIndicator.setAttribute('aria-current', 'true');
1308 }
1309 }
1310 _updateInterval() {
1311 const element = this._activeElement || this._getActive();
1312 if (!element) {
1313 return;
1314 }
1315 const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
1316 this._config.interval = elementInterval || this._config.defaultInterval;
1317 }
1318 _slide(order, element = null) {
1319 if (this._isSliding) {
1320 return;
1321 }
1322 const activeElement = this._getActive();
1323 const isNext = order === ORDER_NEXT;
1324 const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);
1325 if (nextElement === activeElement) {
1326 return;
1327 }
1328 const nextElementIndex = this._getItemIndex(nextElement);
1329 const triggerEvent = eventName => {
1330 return EventHandler.trigger(this._element, eventName, {
1331 relatedTarget: nextElement,
1332 direction: this._orderToDirection(order),
1333 from: this._getItemIndex(activeElement),
1334 to: nextElementIndex
1335 });
1336 };
1337 const slideEvent = triggerEvent(EVENT_SLIDE);
1338 if (slideEvent.defaultPrevented) {
1339 return;
1340 }
1341 if (!activeElement || !nextElement) {
1342 // Some weirdness is happening, so we bail
1343 // TODO: change tests that use empty divs to avoid this check
1344 return;
1345 }
1346 const isCycling = Boolean(this._interval);
1347 this.pause();
1348 this._isSliding = true;
1349 this._setActiveIndicatorElement(nextElementIndex);
1350 this._activeElement = nextElement;
1351 const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
1352 const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
1353 nextElement.classList.add(orderClassName);
1354 reflow(nextElement);
1355 activeElement.classList.add(directionalClassName);
1356 nextElement.classList.add(directionalClassName);
1357 const completeCallBack = () => {
1358 nextElement.classList.remove(directionalClassName, orderClassName);
1359 nextElement.classList.add(CLASS_NAME_ACTIVE$2);
1360 activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
1361 this._isSliding = false;
1362 triggerEvent(EVENT_SLID);
1363 };
1364 this._queueCallback(completeCallBack, activeElement, this._isAnimated());
1365 if (isCycling) {
1366 this.cycle();
1367 }
1368 }
1369 _isAnimated() {
1370 return this._element.classList.contains(CLASS_NAME_SLIDE);
1371 }
1372 _getActive() {
1373 return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
1374 }
1375 _getItems() {
1376 return SelectorEngine.find(SELECTOR_ITEM, this._element);
1377 }
1378 _clearInterval() {
1379 if (this._interval) {
1380 clearInterval(this._interval);
1381 this._interval = null;
1382 }
1383 }
1384 _directionToOrder(direction) {
1385 if (isRTL()) {
1386 return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
1387 }
1388 return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
1389 }
1390 _orderToDirection(order) {
1391 if (isRTL()) {
1392 return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
1393 }
1394 return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
1395 }
1396
1397 // Static
1398 static jQueryInterface(config) {
1399 return this.each(function () {
1400 const data = Carousel.getOrCreateInstance(this, config);
1401 if (typeof config === 'number') {
1402 data.to(config);
1403 return;
1404 }
1405 if (typeof config === 'string') {
1406 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
1407 throw new TypeError(`No method named "${config}"`);
1408 }
1409 data[config]();
1410 }
1411 });
1412 }
1413 }
1414
1415 /**
1416 * Data API implementation
1417 */
1418
1419 EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, function (event) {
1420 const target = SelectorEngine.getElementFromSelector(this);
1421 if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
1422 return;
1423 }
1424 event.preventDefault();
1425 const carousel = Carousel.getOrCreateInstance(target);
1426 const slideIndex = this.getAttribute('data-bs-slide-to');
1427 if (slideIndex) {
1428 carousel.to(slideIndex);
1429 carousel._maybeEnableCycle();
1430 return;
1431 }
1432 if (Manipulator.getDataAttribute(this, 'slide') === 'next') {
1433 carousel.next();
1434 carousel._maybeEnableCycle();
1435 return;
1436 }
1437 carousel.prev();
1438 carousel._maybeEnableCycle();
1439 });
1440 EventHandler.on(window, EVENT_LOAD_DATA_API$3, () => {
1441 const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
1442 for (const carousel of carousels) {
1443 Carousel.getOrCreateInstance(carousel);
1444 }
1445 });
1446
1447 /**
1448 * jQuery
1449 */
1450
1451 defineJQueryPlugin(Carousel);
1452
1453 /**
1454 * --------------------------------------------------------------------------
1455 * Bootstrap collapse.js
1456 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1457 * --------------------------------------------------------------------------
1458 */
1459
1460
1461 /**
1462 * Constants
1463 */
1464
1465 const NAME$b = 'collapse';
1466 const DATA_KEY$7 = 'bs.collapse';
1467 const EVENT_KEY$7 = `.${DATA_KEY$7}`;
1468 const DATA_API_KEY$4 = '.data-api';
1469 const EVENT_SHOW$6 = `show${EVENT_KEY$7}`;
1470 const EVENT_SHOWN$6 = `shown${EVENT_KEY$7}`;
1471 const EVENT_HIDE$6 = `hide${EVENT_KEY$7}`;
1472 const EVENT_HIDDEN$6 = `hidden${EVENT_KEY$7}`;
1473 const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`;
1474 const CLASS_NAME_SHOW$7 = 'show';
1475 const CLASS_NAME_COLLAPSE = 'collapse';
1476 const CLASS_NAME_COLLAPSING = 'collapsing';
1477 const CLASS_NAME_COLLAPSED = 'collapsed';
1478 const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`;
1479 const CLASS_NAME_HORIZONTAL = 'collapse-horizontal';
1480 const WIDTH = 'width';
1481 const HEIGHT = 'height';
1482 const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';
1483 const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]';
1484 const Default$a = {
1485 parent: null,
1486 toggle: true
1487 };
1488 const DefaultType$a = {
1489 parent: '(null|element)',
1490 toggle: 'boolean'
1491 };
1492
1493 /**
1494 * Class definition
1495 */
1496
1497 class Collapse extends BaseComponent {
1498 constructor(element, config) {
1499 super(element, config);
1500 this._isTransitioning = false;
1501 this._triggerArray = [];
1502 const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);
1503 for (const elem of toggleList) {
1504 const selector = SelectorEngine.getSelectorFromElement(elem);
1505 const filterElement = SelectorEngine.find(selector).filter(foundElement => foundElement === this._element);
1506 if (selector !== null && filterElement.length) {
1507 this._triggerArray.push(elem);
1508 }
1509 }
1510 this._initializeChildren();
1511 if (!this._config.parent) {
1512 this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());
1513 }
1514 if (this._config.toggle) {
1515 this.toggle();
1516 }
1517 }
1518
1519 // Getters
1520 static get Default() {
1521 return Default$a;
1522 }
1523 static get DefaultType() {
1524 return DefaultType$a;
1525 }
1526 static get NAME() {
1527 return NAME$b;
1528 }
1529
1530 // Public
1531 toggle() {
1532 if (this._isShown()) {
1533 this.hide();
1534 } else {
1535 this.show();
1536 }
1537 }
1538 show() {
1539 if (this._isTransitioning || this._isShown()) {
1540 return;
1541 }
1542 let activeChildren = [];
1543
1544 // find active children
1545 if (this._config.parent) {
1546 activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES).filter(element => element !== this._element).map(element => Collapse.getOrCreateInstance(element, {
1547 toggle: false
1548 }));
1549 }
1550 if (activeChildren.length && activeChildren[0]._isTransitioning) {
1551 return;
1552 }
1553 const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$6);
1554 if (startEvent.defaultPrevented) {
1555 return;
1556 }
1557 for (const activeInstance of activeChildren) {
1558 activeInstance.hide();
1559 }
1560 const dimension = this._getDimension();
1561 this._element.classList.remove(CLASS_NAME_COLLAPSE);
1562 this._element.classList.add(CLASS_NAME_COLLAPSING);
1563 this._element.style[dimension] = 0;
1564 this._addAriaAndCollapsedClass(this._triggerArray, true);
1565 this._isTransitioning = true;
1566 const complete = () => {
1567 this._isTransitioning = false;
1568 this._element.classList.remove(CLASS_NAME_COLLAPSING);
1569 this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
1570 this._element.style[dimension] = '';
1571 EventHandler.trigger(this._element, EVENT_SHOWN$6);
1572 };
1573 const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
1574 const scrollSize = `scroll${capitalizedDimension}`;
1575 this._queueCallback(complete, this._element, true);
1576 this._element.style[dimension] = `${this._element[scrollSize]}px`;
1577 }
1578 hide() {
1579 if (this._isTransitioning || !this._isShown()) {
1580 return;
1581 }
1582 const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6);
1583 if (startEvent.defaultPrevented) {
1584 return;
1585 }
1586 const dimension = this._getDimension();
1587 this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;
1588 reflow(this._element);
1589 this._element.classList.add(CLASS_NAME_COLLAPSING);
1590 this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
1591 for (const trigger of this._triggerArray) {
1592 const element = SelectorEngine.getElementFromSelector(trigger);
1593 if (element && !this._isShown(element)) {
1594 this._addAriaAndCollapsedClass([trigger], false);
1595 }
1596 }
1597 this._isTransitioning = true;
1598 const complete = () => {
1599 this._isTransitioning = false;
1600 this._element.classList.remove(CLASS_NAME_COLLAPSING);
1601 this._element.classList.add(CLASS_NAME_COLLAPSE);
1602 EventHandler.trigger(this._element, EVENT_HIDDEN$6);
1603 };
1604 this._element.style[dimension] = '';
1605 this._queueCallback(complete, this._element, true);
1606 }
1607 _isShown(element = this._element) {
1608 return element.classList.contains(CLASS_NAME_SHOW$7);
1609 }
1610
1611 // Private
1612 _configAfterMerge(config) {
1613 config.toggle = Boolean(config.toggle); // Coerce string values
1614 config.parent = getElement(config.parent);
1615 return config;
1616 }
1617 _getDimension() {
1618 return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;
1619 }
1620 _initializeChildren() {
1621 if (!this._config.parent) {
1622 return;
1623 }
1624 const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE$4);
1625 for (const element of children) {
1626 const selected = SelectorEngine.getElementFromSelector(element);
1627 if (selected) {
1628 this._addAriaAndCollapsedClass([element], this._isShown(selected));
1629 }
1630 }
1631 }
1632 _getFirstLevelChildren(selector) {
1633 const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
1634 // remove children if greater depth
1635 return SelectorEngine.find(selector, this._config.parent).filter(element => !children.includes(element));
1636 }
1637 _addAriaAndCollapsedClass(triggerArray, isOpen) {
1638 if (!triggerArray.length) {
1639 return;
1640 }
1641 for (const element of triggerArray) {
1642 element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen);
1643 element.setAttribute('aria-expanded', isOpen);
1644 }
1645 }
1646
1647 // Static
1648 static jQueryInterface(config) {
1649 const _config = {};
1650 if (typeof config === 'string' && /show|hide/.test(config)) {
1651 _config.toggle = false;
1652 }
1653 return this.each(function () {
1654 const data = Collapse.getOrCreateInstance(this, _config);
1655 if (typeof config === 'string') {
1656 if (typeof data[config] === 'undefined') {
1657 throw new TypeError(`No method named "${config}"`);
1658 }
1659 data[config]();
1660 }
1661 });
1662 }
1663 }
1664
1665 /**
1666 * Data API implementation
1667 */
1668
1669 EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {
1670 // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
1671 if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
1672 event.preventDefault();
1673 }
1674 for (const element of SelectorEngine.getMultipleElementsFromSelector(this)) {
1675 Collapse.getOrCreateInstance(element, {
1676 toggle: false
1677 }).toggle();
1678 }
1679 });
1680
1681 /**
1682 * jQuery
1683 */
1684
1685 defineJQueryPlugin(Collapse);
1686
1687 var top = 'top';
1688 var bottom = 'bottom';
1689 var right = 'right';
1690 var left = 'left';
1691 var auto = 'auto';
1692 var basePlacements = [top, bottom, right, left];
1693 var start = 'start';
1694 var end = 'end';
1695 var clippingParents = 'clippingParents';
1696 var viewport = 'viewport';
1697 var popper = 'popper';
1698 var reference = 'reference';
1699 var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {
1700 return acc.concat([placement + "-" + start, placement + "-" + end]);
1701 }, []);
1702 var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {
1703 return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
1704 }, []); // modifiers that need to read the DOM
1705
1706 var beforeRead = 'beforeRead';
1707 var read = 'read';
1708 var afterRead = 'afterRead'; // pure-logic modifiers
1709
1710 var beforeMain = 'beforeMain';
1711 var main = 'main';
1712 var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)
1713
1714 var beforeWrite = 'beforeWrite';
1715 var write = 'write';
1716 var afterWrite = 'afterWrite';
1717 var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
1718
1719 function getNodeName(element) {
1720 return element ? (element.nodeName || '').toLowerCase() : null;
1721 }
1722
1723 function getWindow(node) {
1724 if (node == null) {
1725 return window;
1726 }
1727
1728 if (node.toString() !== '[object Window]') {
1729 var ownerDocument = node.ownerDocument;
1730 return ownerDocument ? ownerDocument.defaultView || window : window;
1731 }
1732
1733 return node;
1734 }
1735
1736 function isElement(node) {
1737 var OwnElement = getWindow(node).Element;
1738 return node instanceof OwnElement || node instanceof Element;
1739 }
1740
1741 function isHTMLElement(node) {
1742 var OwnElement = getWindow(node).HTMLElement;
1743 return node instanceof OwnElement || node instanceof HTMLElement;
1744 }
1745
1746 function isShadowRoot(node) {
1747 // IE 11 has no ShadowRoot
1748 if (typeof ShadowRoot === 'undefined') {
1749 return false;
1750 }
1751
1752 var OwnElement = getWindow(node).ShadowRoot;
1753 return node instanceof OwnElement || node instanceof ShadowRoot;
1754 }
1755
1756 // and applies them to the HTMLElements such as popper and arrow
1757
1758 function applyStyles(_ref) {
1759 var state = _ref.state;
1760 Object.keys(state.elements).forEach(function (name) {
1761 var style = state.styles[name] || {};
1762 var attributes = state.attributes[name] || {};
1763 var element = state.elements[name]; // arrow is optional + virtual elements
1764
1765 if (!isHTMLElement(element) || !getNodeName(element)) {
1766 return;
1767 } // Flow doesn't support to extend this property, but it's the most
1768 // effective way to apply styles to an HTMLElement
1769 // $FlowFixMe[cannot-write]
1770
1771
1772 Object.assign(element.style, style);
1773 Object.keys(attributes).forEach(function (name) {
1774 var value = attributes[name];
1775
1776 if (value === false) {
1777 element.removeAttribute(name);
1778 } else {
1779 element.setAttribute(name, value === true ? '' : value);
1780 }
1781 });
1782 });
1783 }
1784
1785 function effect$2(_ref2) {
1786 var state = _ref2.state;
1787 var initialStyles = {
1788 popper: {
1789 position: state.options.strategy,
1790 left: '0',
1791 top: '0',
1792 margin: '0'
1793 },
1794 arrow: {
1795 position: 'absolute'
1796 },
1797 reference: {}
1798 };
1799 Object.assign(state.elements.popper.style, initialStyles.popper);
1800 state.styles = initialStyles;
1801
1802 if (state.elements.arrow) {
1803 Object.assign(state.elements.arrow.style, initialStyles.arrow);
1804 }
1805
1806 return function () {
1807 Object.keys(state.elements).forEach(function (name) {
1808 var element = state.elements[name];
1809 var attributes = state.attributes[name] || {};
1810 var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
1811
1812 var style = styleProperties.reduce(function (style, property) {
1813 style[property] = '';
1814 return style;
1815 }, {}); // arrow is optional + virtual elements
1816
1817 if (!isHTMLElement(element) || !getNodeName(element)) {
1818 return;
1819 }
1820
1821 Object.assign(element.style, style);
1822 Object.keys(attributes).forEach(function (attribute) {
1823 element.removeAttribute(attribute);
1824 });
1825 });
1826 };
1827 } // eslint-disable-next-line import/no-unused-modules
1828
1829
1830 const applyStyles$1 = {
1831 name: 'applyStyles',
1832 enabled: true,
1833 phase: 'write',
1834 fn: applyStyles,
1835 effect: effect$2,
1836 requires: ['computeStyles']
1837 };
1838
1839 function getBasePlacement(placement) {
1840 return placement.split('-')[0];
1841 }
1842
1843 var max = Math.max;
1844 var min = Math.min;
1845 var round = Math.round;
1846
1847 function getUAString() {
1848 var uaData = navigator.userAgentData;
1849
1850 if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) {
1851 return uaData.brands.map(function (item) {
1852 return item.brand + "/" + item.version;
1853 }).join(' ');
1854 }
1855
1856 return navigator.userAgent;
1857 }
1858
1859 function isLayoutViewport() {
1860 return !/^((?!chrome|android).)*safari/i.test(getUAString());
1861 }
1862
1863 function getBoundingClientRect(element, includeScale, isFixedStrategy) {
1864 if (includeScale === void 0) {
1865 includeScale = false;
1866 }
1867
1868 if (isFixedStrategy === void 0) {
1869 isFixedStrategy = false;
1870 }
1871
1872 var clientRect = element.getBoundingClientRect();
1873 var scaleX = 1;
1874 var scaleY = 1;
1875
1876 if (includeScale && isHTMLElement(element)) {
1877 scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
1878 scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
1879 }
1880
1881 var _ref = isElement(element) ? getWindow(element) : window,
1882 visualViewport = _ref.visualViewport;
1883
1884 var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
1885 var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
1886 var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
1887 var width = clientRect.width / scaleX;
1888 var height = clientRect.height / scaleY;
1889 return {
1890 width: width,
1891 height: height,
1892 top: y,
1893 right: x + width,
1894 bottom: y + height,
1895 left: x,
1896 x: x,
1897 y: y
1898 };
1899 }
1900
1901 // means it doesn't take into account transforms.
1902
1903 function getLayoutRect(element) {
1904 var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.
1905 // Fixes https://github.com/popperjs/popper-core/issues/1223
1906
1907 var width = element.offsetWidth;
1908 var height = element.offsetHeight;
1909
1910 if (Math.abs(clientRect.width - width) <= 1) {
1911 width = clientRect.width;
1912 }
1913
1914 if (Math.abs(clientRect.height - height) <= 1) {
1915 height = clientRect.height;
1916 }
1917
1918 return {
1919 x: element.offsetLeft,
1920 y: element.offsetTop,
1921 width: width,
1922 height: height
1923 };
1924 }
1925
1926 function contains(parent, child) {
1927 var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method
1928
1929 if (parent.contains(child)) {
1930 return true;
1931 } // then fallback to custom implementation with Shadow DOM support
1932 else if (rootNode && isShadowRoot(rootNode)) {
1933 var next = child;
1934
1935 do {
1936 if (next && parent.isSameNode(next)) {
1937 return true;
1938 } // $FlowFixMe[prop-missing]: need a better way to handle this...
1939
1940
1941 next = next.parentNode || next.host;
1942 } while (next);
1943 } // Give up, the result is false
1944
1945
1946 return false;
1947 }
1948
1949 function getComputedStyle$1(element) {
1950 return getWindow(element).getComputedStyle(element);
1951 }
1952
1953 function isTableElement(element) {
1954 return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
1955 }
1956
1957 function getDocumentElement(element) {
1958 // $FlowFixMe[incompatible-return]: assume body is always available
1959 return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
1960 element.document) || window.document).documentElement;
1961 }
1962
1963 function getParentNode(element) {
1964 if (getNodeName(element) === 'html') {
1965 return element;
1966 }
1967
1968 return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
1969 // $FlowFixMe[incompatible-return]
1970 // $FlowFixMe[prop-missing]
1971 element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
1972 element.parentNode || ( // DOM Element detected
1973 isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
1974 // $FlowFixMe[incompatible-call]: HTMLElement is a Node
1975 getDocumentElement(element) // fallback
1976
1977 );
1978 }
1979
1980 function getTrueOffsetParent(element) {
1981 if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
1982 getComputedStyle$1(element).position === 'fixed') {
1983 return null;
1984 }
1985
1986 return element.offsetParent;
1987 } // `.offsetParent` reports `null` for fixed elements, while absolute elements
1988 // return the containing block
1989
1990
1991 function getContainingBlock(element) {
1992 var isFirefox = /firefox/i.test(getUAString());
1993 var isIE = /Trident/i.test(getUAString());
1994
1995 if (isIE && isHTMLElement(element)) {
1996 // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
1997 var elementCss = getComputedStyle$1(element);
1998
1999 if (elementCss.position === 'fixed') {
2000 return null;
2001 }
2002 }
2003
2004 var currentNode = getParentNode(element);
2005
2006 if (isShadowRoot(currentNode)) {
2007 currentNode = currentNode.host;
2008 }
2009
2010 while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
2011 var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that
2012 // create a containing block.
2013 // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
2014
2015 if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') {
2016 return currentNode;
2017 } else {
2018 currentNode = currentNode.parentNode;
2019 }
2020 }
2021
2022 return null;
2023 } // Gets the closest ancestor positioned element. Handles some edge cases,
2024 // such as table ancestors and cross browser bugs.
2025
2026
2027 function getOffsetParent(element) {
2028 var window = getWindow(element);
2029 var offsetParent = getTrueOffsetParent(element);
2030
2031 while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
2032 offsetParent = getTrueOffsetParent(offsetParent);
2033 }
2034
2035 if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static')) {
2036 return window;
2037 }
2038
2039 return offsetParent || getContainingBlock(element) || window;
2040 }
2041
2042 function getMainAxisFromPlacement(placement) {
2043 return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
2044 }
2045
2046 function within(min$1, value, max$1) {
2047 return max(min$1, min(value, max$1));
2048 }
2049 function withinMaxClamp(min, value, max) {
2050 var v = within(min, value, max);
2051 return v > max ? max : v;
2052 }
2053
2054 function getFreshSideObject() {
2055 return {
2056 top: 0,
2057 right: 0,
2058 bottom: 0,
2059 left: 0
2060 };
2061 }
2062
2063 function mergePaddingObject(paddingObject) {
2064 return Object.assign({}, getFreshSideObject(), paddingObject);
2065 }
2066
2067 function expandToHashMap(value, keys) {
2068 return keys.reduce(function (hashMap, key) {
2069 hashMap[key] = value;
2070 return hashMap;
2071 }, {});
2072 }
2073
2074 var toPaddingObject = function toPaddingObject(padding, state) {
2075 padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, {
2076 placement: state.placement
2077 })) : padding;
2078 return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2079 };
2080
2081 function arrow(_ref) {
2082 var _state$modifiersData$;
2083
2084 var state = _ref.state,
2085 name = _ref.name,
2086 options = _ref.options;
2087 var arrowElement = state.elements.arrow;
2088 var popperOffsets = state.modifiersData.popperOffsets;
2089 var basePlacement = getBasePlacement(state.placement);
2090 var axis = getMainAxisFromPlacement(basePlacement);
2091 var isVertical = [left, right].indexOf(basePlacement) >= 0;
2092 var len = isVertical ? 'height' : 'width';
2093
2094 if (!arrowElement || !popperOffsets) {
2095 return;
2096 }
2097
2098 var paddingObject = toPaddingObject(options.padding, state);
2099 var arrowRect = getLayoutRect(arrowElement);
2100 var minProp = axis === 'y' ? top : left;
2101 var maxProp = axis === 'y' ? bottom : right;
2102 var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
2103 var startDiff = popperOffsets[axis] - state.rects.reference[axis];
2104 var arrowOffsetParent = getOffsetParent(arrowElement);
2105 var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
2106 var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
2107 // outside of the popper bounds
2108
2109 var min = paddingObject[minProp];
2110 var max = clientSize - arrowRect[len] - paddingObject[maxProp];
2111 var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
2112 var offset = within(min, center, max); // Prevents breaking syntax highlighting...
2113
2114 var axisProp = axis;
2115 state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
2116 }
2117
2118 function effect$1(_ref2) {
2119 var state = _ref2.state,
2120 options = _ref2.options;
2121 var _options$element = options.element,
2122 arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element;
2123
2124 if (arrowElement == null) {
2125 return;
2126 } // CSS selector
2127
2128
2129 if (typeof arrowElement === 'string') {
2130 arrowElement = state.elements.popper.querySelector(arrowElement);
2131
2132 if (!arrowElement) {
2133 return;
2134 }
2135 }
2136
2137 if (!contains(state.elements.popper, arrowElement)) {
2138 return;
2139 }
2140
2141 state.elements.arrow = arrowElement;
2142 } // eslint-disable-next-line import/no-unused-modules
2143
2144
2145 const arrow$1 = {
2146 name: 'arrow',
2147 enabled: true,
2148 phase: 'main',
2149 fn: arrow,
2150 effect: effect$1,
2151 requires: ['popperOffsets'],
2152 requiresIfExists: ['preventOverflow']
2153 };
2154
2155 function getVariation(placement) {
2156 return placement.split('-')[1];
2157 }
2158
2159 var unsetSides = {
2160 top: 'auto',
2161 right: 'auto',
2162 bottom: 'auto',
2163 left: 'auto'
2164 }; // Round the offsets to the nearest suitable subpixel based on the DPR.
2165 // Zooming can change the DPR, but it seems to report a value that will
2166 // cleanly divide the values into the appropriate subpixels.
2167
2168 function roundOffsetsByDPR(_ref, win) {
2169 var x = _ref.x,
2170 y = _ref.y;
2171 var dpr = win.devicePixelRatio || 1;
2172 return {
2173 x: round(x * dpr) / dpr || 0,
2174 y: round(y * dpr) / dpr || 0
2175 };
2176 }
2177
2178 function mapToStyles(_ref2) {
2179 var _Object$assign2;
2180
2181 var popper = _ref2.popper,
2182 popperRect = _ref2.popperRect,
2183 placement = _ref2.placement,
2184 variation = _ref2.variation,
2185 offsets = _ref2.offsets,
2186 position = _ref2.position,
2187 gpuAcceleration = _ref2.gpuAcceleration,
2188 adaptive = _ref2.adaptive,
2189 roundOffsets = _ref2.roundOffsets,
2190 isFixed = _ref2.isFixed;
2191 var _offsets$x = offsets.x,
2192 x = _offsets$x === void 0 ? 0 : _offsets$x,
2193 _offsets$y = offsets.y,
2194 y = _offsets$y === void 0 ? 0 : _offsets$y;
2195
2196 var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({
2197 x: x,
2198 y: y
2199 }) : {
2200 x: x,
2201 y: y
2202 };
2203
2204 x = _ref3.x;
2205 y = _ref3.y;
2206 var hasX = offsets.hasOwnProperty('x');
2207 var hasY = offsets.hasOwnProperty('y');
2208 var sideX = left;
2209 var sideY = top;
2210 var win = window;
2211
2212 if (adaptive) {
2213 var offsetParent = getOffsetParent(popper);
2214 var heightProp = 'clientHeight';
2215 var widthProp = 'clientWidth';
2216
2217 if (offsetParent === getWindow(popper)) {
2218 offsetParent = getDocumentElement(popper);
2219
2220 if (getComputedStyle$1(offsetParent).position !== 'static' && position === 'absolute') {
2221 heightProp = 'scrollHeight';
2222 widthProp = 'scrollWidth';
2223 }
2224 } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
2225
2226
2227 offsetParent = offsetParent;
2228
2229 if (placement === top || (placement === left || placement === right) && variation === end) {
2230 sideY = bottom;
2231 var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing]
2232 offsetParent[heightProp];
2233 y -= offsetY - popperRect.height;
2234 y *= gpuAcceleration ? 1 : -1;
2235 }
2236
2237 if (placement === left || (placement === top || placement === bottom) && variation === end) {
2238 sideX = right;
2239 var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing]
2240 offsetParent[widthProp];
2241 x -= offsetX - popperRect.width;
2242 x *= gpuAcceleration ? 1 : -1;
2243 }
2244 }
2245
2246 var commonStyles = Object.assign({
2247 position: position
2248 }, adaptive && unsetSides);
2249
2250 var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
2251 x: x,
2252 y: y
2253 }, getWindow(popper)) : {
2254 x: x,
2255 y: y
2256 };
2257
2258 x = _ref4.x;
2259 y = _ref4.y;
2260
2261 if (gpuAcceleration) {
2262 var _Object$assign;
2263
2264 return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
2265 }
2266
2267 return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
2268 }
2269
2270 function computeStyles(_ref5) {
2271 var state = _ref5.state,
2272 options = _ref5.options;
2273 var _options$gpuAccelerat = options.gpuAcceleration,
2274 gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
2275 _options$adaptive = options.adaptive,
2276 adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
2277 _options$roundOffsets = options.roundOffsets,
2278 roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
2279 var commonStyles = {
2280 placement: getBasePlacement(state.placement),
2281 variation: getVariation(state.placement),
2282 popper: state.elements.popper,
2283 popperRect: state.rects.popper,
2284 gpuAcceleration: gpuAcceleration,
2285 isFixed: state.options.strategy === 'fixed'
2286 };
2287
2288 if (state.modifiersData.popperOffsets != null) {
2289 state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
2290 offsets: state.modifiersData.popperOffsets,
2291 position: state.options.strategy,
2292 adaptive: adaptive,
2293 roundOffsets: roundOffsets
2294 })));
2295 }
2296
2297 if (state.modifiersData.arrow != null) {
2298 state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
2299 offsets: state.modifiersData.arrow,
2300 position: 'absolute',
2301 adaptive: false,
2302 roundOffsets: roundOffsets
2303 })));
2304 }
2305
2306 state.attributes.popper = Object.assign({}, state.attributes.popper, {
2307 'data-popper-placement': state.placement
2308 });
2309 } // eslint-disable-next-line import/no-unused-modules
2310
2311
2312 const computeStyles$1 = {
2313 name: 'computeStyles',
2314 enabled: true,
2315 phase: 'beforeWrite',
2316 fn: computeStyles,
2317 data: {}
2318 };
2319
2320 var passive = {
2321 passive: true
2322 };
2323
2324 function effect(_ref) {
2325 var state = _ref.state,
2326 instance = _ref.instance,
2327 options = _ref.options;
2328 var _options$scroll = options.scroll,
2329 scroll = _options$scroll === void 0 ? true : _options$scroll,
2330 _options$resize = options.resize,
2331 resize = _options$resize === void 0 ? true : _options$resize;
2332 var window = getWindow(state.elements.popper);
2333 var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
2334
2335 if (scroll) {
2336 scrollParents.forEach(function (scrollParent) {
2337 scrollParent.addEventListener('scroll', instance.update, passive);
2338 });
2339 }
2340
2341 if (resize) {
2342 window.addEventListener('resize', instance.update, passive);
2343 }
2344
2345 return function () {
2346 if (scroll) {
2347 scrollParents.forEach(function (scrollParent) {
2348 scrollParent.removeEventListener('scroll', instance.update, passive);
2349 });
2350 }
2351
2352 if (resize) {
2353 window.removeEventListener('resize', instance.update, passive);
2354 }
2355 };
2356 } // eslint-disable-next-line import/no-unused-modules
2357
2358
2359 const eventListeners = {
2360 name: 'eventListeners',
2361 enabled: true,
2362 phase: 'write',
2363 fn: function fn() {},
2364 effect: effect,
2365 data: {}
2366 };
2367
2368 var hash$1 = {
2369 left: 'right',
2370 right: 'left',
2371 bottom: 'top',
2372 top: 'bottom'
2373 };
2374 function getOppositePlacement(placement) {
2375 return placement.replace(/left|right|bottom|top/g, function (matched) {
2376 return hash$1[matched];
2377 });
2378 }
2379
2380 var hash = {
2381 start: 'end',
2382 end: 'start'
2383 };
2384 function getOppositeVariationPlacement(placement) {
2385 return placement.replace(/start|end/g, function (matched) {
2386 return hash[matched];
2387 });
2388 }
2389
2390 function getWindowScroll(node) {
2391 var win = getWindow(node);
2392 var scrollLeft = win.pageXOffset;
2393 var scrollTop = win.pageYOffset;
2394 return {
2395 scrollLeft: scrollLeft,
2396 scrollTop: scrollTop
2397 };
2398 }
2399
2400 function getWindowScrollBarX(element) {
2401 // If <html> has a CSS width greater than the viewport, then this will be
2402 // incorrect for RTL.
2403 // Popper 1 is broken in this case and never had a bug report so let's assume
2404 // it's not an issue. I don't think anyone ever specifies width on <html>
2405 // anyway.
2406 // Browsers where the left scrollbar doesn't cause an issue report `0` for
2407 // this (e.g. Edge 2019, IE11, Safari)
2408 return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
2409 }
2410
2411 function getViewportRect(element, strategy) {
2412 var win = getWindow(element);
2413 var html = getDocumentElement(element);
2414 var visualViewport = win.visualViewport;
2415 var width = html.clientWidth;
2416 var height = html.clientHeight;
2417 var x = 0;
2418 var y = 0;
2419
2420 if (visualViewport) {
2421 width = visualViewport.width;
2422 height = visualViewport.height;
2423 var layoutViewport = isLayoutViewport();
2424
2425 if (layoutViewport || !layoutViewport && strategy === 'fixed') {
2426 x = visualViewport.offsetLeft;
2427 y = visualViewport.offsetTop;
2428 }
2429 }
2430
2431 return {
2432 width: width,
2433 height: height,
2434 x: x + getWindowScrollBarX(element),
2435 y: y
2436 };
2437 }
2438
2439 // of the `<html>` and `<body>` rect bounds if horizontally scrollable
2440
2441 function getDocumentRect(element) {
2442 var _element$ownerDocumen;
2443
2444 var html = getDocumentElement(element);
2445 var winScroll = getWindowScroll(element);
2446 var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
2447 var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
2448 var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
2449 var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
2450 var y = -winScroll.scrollTop;
2451
2452 if (getComputedStyle$1(body || html).direction === 'rtl') {
2453 x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
2454 }
2455
2456 return {
2457 width: width,
2458 height: height,
2459 x: x,
2460 y: y
2461 };
2462 }
2463
2464 function isScrollParent(element) {
2465 // Firefox wants us to check `-x` and `-y` variations as well
2466 var _getComputedStyle = getComputedStyle$1(element),
2467 overflow = _getComputedStyle.overflow,
2468 overflowX = _getComputedStyle.overflowX,
2469 overflowY = _getComputedStyle.overflowY;
2470
2471 return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
2472 }
2473
2474 function getScrollParent(node) {
2475 if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
2476 // $FlowFixMe[incompatible-return]: assume body is always available
2477 return node.ownerDocument.body;
2478 }
2479
2480 if (isHTMLElement(node) && isScrollParent(node)) {
2481 return node;
2482 }
2483
2484 return getScrollParent(getParentNode(node));
2485 }
2486
2487 /*
2488 given a DOM element, return the list of all scroll parents, up the list of ancesors
2489 until we get to the top window object. This list is what we attach scroll listeners
2490 to, because if any of these parent elements scroll, we'll need to re-calculate the
2491 reference element's position.
2492 */
2493
2494 function listScrollParents(element, list) {
2495 var _element$ownerDocumen;
2496
2497 if (list === void 0) {
2498 list = [];
2499 }
2500
2501 var scrollParent = getScrollParent(element);
2502 var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
2503 var win = getWindow(scrollParent);
2504 var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
2505 var updatedList = list.concat(target);
2506 return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
2507 updatedList.concat(listScrollParents(getParentNode(target)));
2508 }
2509
2510 function rectToClientRect(rect) {
2511 return Object.assign({}, rect, {
2512 left: rect.x,
2513 top: rect.y,
2514 right: rect.x + rect.width,
2515 bottom: rect.y + rect.height
2516 });
2517 }
2518
2519 function getInnerBoundingClientRect(element, strategy) {
2520 var rect = getBoundingClientRect(element, false, strategy === 'fixed');
2521 rect.top = rect.top + element.clientTop;
2522 rect.left = rect.left + element.clientLeft;
2523 rect.bottom = rect.top + element.clientHeight;
2524 rect.right = rect.left + element.clientWidth;
2525 rect.width = element.clientWidth;
2526 rect.height = element.clientHeight;
2527 rect.x = rect.left;
2528 rect.y = rect.top;
2529 return rect;
2530 }
2531
2532 function getClientRectFromMixedType(element, clippingParent, strategy) {
2533 return clippingParent === viewport ? rectToClientRect(getViewportRect(element, strategy)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
2534 } // A "clipping parent" is an overflowable container with the characteristic of
2535 // clipping (or hiding) overflowing elements with a position different from
2536 // `initial`
2537
2538
2539 function getClippingParents(element) {
2540 var clippingParents = listScrollParents(getParentNode(element));
2541 var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0;
2542 var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
2543
2544 if (!isElement(clipperElement)) {
2545 return [];
2546 } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414
2547
2548
2549 return clippingParents.filter(function (clippingParent) {
2550 return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body';
2551 });
2552 } // Gets the maximum area that the element is visible in due to any number of
2553 // clipping parents
2554
2555
2556 function getClippingRect(element, boundary, rootBoundary, strategy) {
2557 var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
2558 var clippingParents = [].concat(mainClippingParents, [rootBoundary]);
2559 var firstClippingParent = clippingParents[0];
2560 var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {
2561 var rect = getClientRectFromMixedType(element, clippingParent, strategy);
2562 accRect.top = max(rect.top, accRect.top);
2563 accRect.right = min(rect.right, accRect.right);
2564 accRect.bottom = min(rect.bottom, accRect.bottom);
2565 accRect.left = max(rect.left, accRect.left);
2566 return accRect;
2567 }, getClientRectFromMixedType(element, firstClippingParent, strategy));
2568 clippingRect.width = clippingRect.right - clippingRect.left;
2569 clippingRect.height = clippingRect.bottom - clippingRect.top;
2570 clippingRect.x = clippingRect.left;
2571 clippingRect.y = clippingRect.top;
2572 return clippingRect;
2573 }
2574
2575 function computeOffsets(_ref) {
2576 var reference = _ref.reference,
2577 element = _ref.element,
2578 placement = _ref.placement;
2579 var basePlacement = placement ? getBasePlacement(placement) : null;
2580 var variation = placement ? getVariation(placement) : null;
2581 var commonX = reference.x + reference.width / 2 - element.width / 2;
2582 var commonY = reference.y + reference.height / 2 - element.height / 2;
2583 var offsets;
2584
2585 switch (basePlacement) {
2586 case top:
2587 offsets = {
2588 x: commonX,
2589 y: reference.y - element.height
2590 };
2591 break;
2592
2593 case bottom:
2594 offsets = {
2595 x: commonX,
2596 y: reference.y + reference.height
2597 };
2598 break;
2599
2600 case right:
2601 offsets = {
2602 x: reference.x + reference.width,
2603 y: commonY
2604 };
2605 break;
2606
2607 case left:
2608 offsets = {
2609 x: reference.x - element.width,
2610 y: commonY
2611 };
2612 break;
2613
2614 default:
2615 offsets = {
2616 x: reference.x,
2617 y: reference.y
2618 };
2619 }
2620
2621 var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
2622
2623 if (mainAxis != null) {
2624 var len = mainAxis === 'y' ? 'height' : 'width';
2625
2626 switch (variation) {
2627 case start:
2628 offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
2629 break;
2630
2631 case end:
2632 offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
2633 break;
2634 }
2635 }
2636
2637 return offsets;
2638 }
2639
2640 function detectOverflow(state, options) {
2641 if (options === void 0) {
2642 options = {};
2643 }
2644
2645 var _options = options,
2646 _options$placement = _options.placement,
2647 placement = _options$placement === void 0 ? state.placement : _options$placement,
2648 _options$strategy = _options.strategy,
2649 strategy = _options$strategy === void 0 ? state.strategy : _options$strategy,
2650 _options$boundary = _options.boundary,
2651 boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,
2652 _options$rootBoundary = _options.rootBoundary,
2653 rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,
2654 _options$elementConte = _options.elementContext,
2655 elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,
2656 _options$altBoundary = _options.altBoundary,
2657 altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,
2658 _options$padding = _options.padding,
2659 padding = _options$padding === void 0 ? 0 : _options$padding;
2660 var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2661 var altContext = elementContext === popper ? reference : popper;
2662 var popperRect = state.rects.popper;
2663 var element = state.elements[altBoundary ? altContext : elementContext];
2664 var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy);
2665 var referenceClientRect = getBoundingClientRect(state.elements.reference);
2666 var popperOffsets = computeOffsets({
2667 reference: referenceClientRect,
2668 element: popperRect,
2669 strategy: 'absolute',
2670 placement: placement
2671 });
2672 var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets));
2673 var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect
2674 // 0 or negative = within the clipping rect
2675
2676 var overflowOffsets = {
2677 top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
2678 bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
2679 left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
2680 right: elementClientRect.right - clippingClientRect.right + paddingObject.right
2681 };
2682 var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element
2683
2684 if (elementContext === popper && offsetData) {
2685 var offset = offsetData[placement];
2686 Object.keys(overflowOffsets).forEach(function (key) {
2687 var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
2688 var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x';
2689 overflowOffsets[key] += offset[axis] * multiply;
2690 });
2691 }
2692
2693 return overflowOffsets;
2694 }
2695
2696 function computeAutoPlacement(state, options) {
2697 if (options === void 0) {
2698 options = {};
2699 }
2700
2701 var _options = options,
2702 placement = _options.placement,
2703 boundary = _options.boundary,
2704 rootBoundary = _options.rootBoundary,
2705 padding = _options.padding,
2706 flipVariations = _options.flipVariations,
2707 _options$allowedAutoP = _options.allowedAutoPlacements,
2708 allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;
2709 var variation = getVariation(placement);
2710 var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) {
2711 return getVariation(placement) === variation;
2712 }) : basePlacements;
2713 var allowedPlacements = placements$1.filter(function (placement) {
2714 return allowedAutoPlacements.indexOf(placement) >= 0;
2715 });
2716
2717 if (allowedPlacements.length === 0) {
2718 allowedPlacements = placements$1;
2719 } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...
2720
2721
2722 var overflows = allowedPlacements.reduce(function (acc, placement) {
2723 acc[placement] = detectOverflow(state, {
2724 placement: placement,
2725 boundary: boundary,
2726 rootBoundary: rootBoundary,
2727 padding: padding
2728 })[getBasePlacement(placement)];
2729 return acc;
2730 }, {});
2731 return Object.keys(overflows).sort(function (a, b) {
2732 return overflows[a] - overflows[b];
2733 });
2734 }
2735
2736 function getExpandedFallbackPlacements(placement) {
2737 if (getBasePlacement(placement) === auto) {
2738 return [];
2739 }
2740
2741 var oppositePlacement = getOppositePlacement(placement);
2742 return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
2743 }
2744
2745 function flip(_ref) {
2746 var state = _ref.state,
2747 options = _ref.options,
2748 name = _ref.name;
2749
2750 if (state.modifiersData[name]._skip) {
2751 return;
2752 }
2753
2754 var _options$mainAxis = options.mainAxis,
2755 checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
2756 _options$altAxis = options.altAxis,
2757 checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis,
2758 specifiedFallbackPlacements = options.fallbackPlacements,
2759 padding = options.padding,
2760 boundary = options.boundary,
2761 rootBoundary = options.rootBoundary,
2762 altBoundary = options.altBoundary,
2763 _options$flipVariatio = options.flipVariations,
2764 flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio,
2765 allowedAutoPlacements = options.allowedAutoPlacements;
2766 var preferredPlacement = state.options.placement;
2767 var basePlacement = getBasePlacement(preferredPlacement);
2768 var isBasePlacement = basePlacement === preferredPlacement;
2769 var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
2770 var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) {
2771 return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, {
2772 placement: placement,
2773 boundary: boundary,
2774 rootBoundary: rootBoundary,
2775 padding: padding,
2776 flipVariations: flipVariations,
2777 allowedAutoPlacements: allowedAutoPlacements
2778 }) : placement);
2779 }, []);
2780 var referenceRect = state.rects.reference;
2781 var popperRect = state.rects.popper;
2782 var checksMap = new Map();
2783 var makeFallbackChecks = true;
2784 var firstFittingPlacement = placements[0];
2785
2786 for (var i = 0; i < placements.length; i++) {
2787 var placement = placements[i];
2788
2789 var _basePlacement = getBasePlacement(placement);
2790
2791 var isStartVariation = getVariation(placement) === start;
2792 var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;
2793 var len = isVertical ? 'width' : 'height';
2794 var overflow = detectOverflow(state, {
2795 placement: placement,
2796 boundary: boundary,
2797 rootBoundary: rootBoundary,
2798 altBoundary: altBoundary,
2799 padding: padding
2800 });
2801 var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
2802
2803 if (referenceRect[len] > popperRect[len]) {
2804 mainVariationSide = getOppositePlacement(mainVariationSide);
2805 }
2806
2807 var altVariationSide = getOppositePlacement(mainVariationSide);
2808 var checks = [];
2809
2810 if (checkMainAxis) {
2811 checks.push(overflow[_basePlacement] <= 0);
2812 }
2813
2814 if (checkAltAxis) {
2815 checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
2816 }
2817
2818 if (checks.every(function (check) {
2819 return check;
2820 })) {
2821 firstFittingPlacement = placement;
2822 makeFallbackChecks = false;
2823 break;
2824 }
2825
2826 checksMap.set(placement, checks);
2827 }
2828
2829 if (makeFallbackChecks) {
2830 // `2` may be desired in some cases – research later
2831 var numberOfChecks = flipVariations ? 3 : 1;
2832
2833 var _loop = function _loop(_i) {
2834 var fittingPlacement = placements.find(function (placement) {
2835 var checks = checksMap.get(placement);
2836
2837 if (checks) {
2838 return checks.slice(0, _i).every(function (check) {
2839 return check;
2840 });
2841 }
2842 });
2843
2844 if (fittingPlacement) {
2845 firstFittingPlacement = fittingPlacement;
2846 return "break";
2847 }
2848 };
2849
2850 for (var _i = numberOfChecks; _i > 0; _i--) {
2851 var _ret = _loop(_i);
2852
2853 if (_ret === "break") break;
2854 }
2855 }
2856
2857 if (state.placement !== firstFittingPlacement) {
2858 state.modifiersData[name]._skip = true;
2859 state.placement = firstFittingPlacement;
2860 state.reset = true;
2861 }
2862 } // eslint-disable-next-line import/no-unused-modules
2863
2864
2865 const flip$1 = {
2866 name: 'flip',
2867 enabled: true,
2868 phase: 'main',
2869 fn: flip,
2870 requiresIfExists: ['offset'],
2871 data: {
2872 _skip: false
2873 }
2874 };
2875
2876 function getSideOffsets(overflow, rect, preventedOffsets) {
2877 if (preventedOffsets === void 0) {
2878 preventedOffsets = {
2879 x: 0,
2880 y: 0
2881 };
2882 }
2883
2884 return {
2885 top: overflow.top - rect.height - preventedOffsets.y,
2886 right: overflow.right - rect.width + preventedOffsets.x,
2887 bottom: overflow.bottom - rect.height + preventedOffsets.y,
2888 left: overflow.left - rect.width - preventedOffsets.x
2889 };
2890 }
2891
2892 function isAnySideFullyClipped(overflow) {
2893 return [top, right, bottom, left].some(function (side) {
2894 return overflow[side] >= 0;
2895 });
2896 }
2897
2898 function hide(_ref) {
2899 var state = _ref.state,
2900 name = _ref.name;
2901 var referenceRect = state.rects.reference;
2902 var popperRect = state.rects.popper;
2903 var preventedOffsets = state.modifiersData.preventOverflow;
2904 var referenceOverflow = detectOverflow(state, {
2905 elementContext: 'reference'
2906 });
2907 var popperAltOverflow = detectOverflow(state, {
2908 altBoundary: true
2909 });
2910 var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
2911 var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
2912 var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
2913 var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
2914 state.modifiersData[name] = {
2915 referenceClippingOffsets: referenceClippingOffsets,
2916 popperEscapeOffsets: popperEscapeOffsets,
2917 isReferenceHidden: isReferenceHidden,
2918 hasPopperEscaped: hasPopperEscaped
2919 };
2920 state.attributes.popper = Object.assign({}, state.attributes.popper, {
2921 'data-popper-reference-hidden': isReferenceHidden,
2922 'data-popper-escaped': hasPopperEscaped
2923 });
2924 } // eslint-disable-next-line import/no-unused-modules
2925
2926
2927 const hide$1 = {
2928 name: 'hide',
2929 enabled: true,
2930 phase: 'main',
2931 requiresIfExists: ['preventOverflow'],
2932 fn: hide
2933 };
2934
2935 function distanceAndSkiddingToXY(placement, rects, offset) {
2936 var basePlacement = getBasePlacement(placement);
2937 var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
2938
2939 var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, {
2940 placement: placement
2941 })) : offset,
2942 skidding = _ref[0],
2943 distance = _ref[1];
2944
2945 skidding = skidding || 0;
2946 distance = (distance || 0) * invertDistance;
2947 return [left, right].indexOf(basePlacement) >= 0 ? {
2948 x: distance,
2949 y: skidding
2950 } : {
2951 x: skidding,
2952 y: distance
2953 };
2954 }
2955
2956 function offset(_ref2) {
2957 var state = _ref2.state,
2958 options = _ref2.options,
2959 name = _ref2.name;
2960 var _options$offset = options.offset,
2961 offset = _options$offset === void 0 ? [0, 0] : _options$offset;
2962 var data = placements.reduce(function (acc, placement) {
2963 acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
2964 return acc;
2965 }, {});
2966 var _data$state$placement = data[state.placement],
2967 x = _data$state$placement.x,
2968 y = _data$state$placement.y;
2969
2970 if (state.modifiersData.popperOffsets != null) {
2971 state.modifiersData.popperOffsets.x += x;
2972 state.modifiersData.popperOffsets.y += y;
2973 }
2974
2975 state.modifiersData[name] = data;
2976 } // eslint-disable-next-line import/no-unused-modules
2977
2978
2979 const offset$1 = {
2980 name: 'offset',
2981 enabled: true,
2982 phase: 'main',
2983 requires: ['popperOffsets'],
2984 fn: offset
2985 };
2986
2987 function popperOffsets(_ref) {
2988 var state = _ref.state,
2989 name = _ref.name;
2990 // Offsets are the actual position the popper needs to have to be
2991 // properly positioned near its reference element
2992 // This is the most basic placement, and will be adjusted by
2993 // the modifiers in the next step
2994 state.modifiersData[name] = computeOffsets({
2995 reference: state.rects.reference,
2996 element: state.rects.popper,
2997 strategy: 'absolute',
2998 placement: state.placement
2999 });
3000 } // eslint-disable-next-line import/no-unused-modules
3001
3002
3003 const popperOffsets$1 = {
3004 name: 'popperOffsets',
3005 enabled: true,
3006 phase: 'read',
3007 fn: popperOffsets,
3008 data: {}
3009 };
3010
3011 function getAltAxis(axis) {
3012 return axis === 'x' ? 'y' : 'x';
3013 }
3014
3015 function preventOverflow(_ref) {
3016 var state = _ref.state,
3017 options = _ref.options,
3018 name = _ref.name;
3019 var _options$mainAxis = options.mainAxis,
3020 checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
3021 _options$altAxis = options.altAxis,
3022 checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis,
3023 boundary = options.boundary,
3024 rootBoundary = options.rootBoundary,
3025 altBoundary = options.altBoundary,
3026 padding = options.padding,
3027 _options$tether = options.tether,
3028 tether = _options$tether === void 0 ? true : _options$tether,
3029 _options$tetherOffset = options.tetherOffset,
3030 tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
3031 var overflow = detectOverflow(state, {
3032 boundary: boundary,
3033 rootBoundary: rootBoundary,
3034 padding: padding,
3035 altBoundary: altBoundary
3036 });
3037 var basePlacement = getBasePlacement(state.placement);
3038 var variation = getVariation(state.placement);
3039 var isBasePlacement = !variation;
3040 var mainAxis = getMainAxisFromPlacement(basePlacement);
3041 var altAxis = getAltAxis(mainAxis);
3042 var popperOffsets = state.modifiersData.popperOffsets;
3043 var referenceRect = state.rects.reference;
3044 var popperRect = state.rects.popper;
3045 var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, {
3046 placement: state.placement
3047 })) : tetherOffset;
3048 var normalizedTetherOffsetValue = typeof tetherOffsetValue === 'number' ? {
3049 mainAxis: tetherOffsetValue,
3050 altAxis: tetherOffsetValue
3051 } : Object.assign({
3052 mainAxis: 0,
3053 altAxis: 0
3054 }, tetherOffsetValue);
3055 var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
3056 var data = {
3057 x: 0,
3058 y: 0
3059 };
3060
3061 if (!popperOffsets) {
3062 return;
3063 }
3064
3065 if (checkMainAxis) {
3066 var _offsetModifierState$;
3067
3068 var mainSide = mainAxis === 'y' ? top : left;
3069 var altSide = mainAxis === 'y' ? bottom : right;
3070 var len = mainAxis === 'y' ? 'height' : 'width';
3071 var offset = popperOffsets[mainAxis];
3072 var min$1 = offset + overflow[mainSide];
3073 var max$1 = offset - overflow[altSide];
3074 var additive = tether ? -popperRect[len] / 2 : 0;
3075 var minLen = variation === start ? referenceRect[len] : popperRect[len];
3076 var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go
3077 // outside the reference bounds
3078
3079 var arrowElement = state.elements.arrow;
3080 var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
3081 width: 0,
3082 height: 0
3083 };
3084 var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject();
3085 var arrowPaddingMin = arrowPaddingObject[mainSide];
3086 var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want
3087 // to include its full size in the calculation. If the reference is small
3088 // and near the edge of a boundary, the popper can overflow even if the
3089 // reference is not overflowing as well (e.g. virtual elements with no
3090 // width or height)
3091
3092 var arrowLen = within(0, referenceRect[len], arrowRect[len]);
3093 var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
3094 var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
3095 var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
3096 var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
3097 var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
3098 var tetherMin = offset + minOffset - offsetModifierValue - clientOffset;
3099 var tetherMax = offset + maxOffset - offsetModifierValue;
3100 var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset, tether ? max(max$1, tetherMax) : max$1);
3101 popperOffsets[mainAxis] = preventedOffset;
3102 data[mainAxis] = preventedOffset - offset;
3103 }
3104
3105 if (checkAltAxis) {
3106 var _offsetModifierState$2;
3107
3108 var _mainSide = mainAxis === 'x' ? top : left;
3109
3110 var _altSide = mainAxis === 'x' ? bottom : right;
3111
3112 var _offset = popperOffsets[altAxis];
3113
3114 var _len = altAxis === 'y' ? 'height' : 'width';
3115
3116 var _min = _offset + overflow[_mainSide];
3117
3118 var _max = _offset - overflow[_altSide];
3119
3120 var isOriginSide = [top, left].indexOf(basePlacement) !== -1;
3121
3122 var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
3123
3124 var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
3125
3126 var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
3127
3128 var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
3129
3130 popperOffsets[altAxis] = _preventedOffset;
3131 data[altAxis] = _preventedOffset - _offset;
3132 }
3133
3134 state.modifiersData[name] = data;
3135 } // eslint-disable-next-line import/no-unused-modules
3136
3137
3138 const preventOverflow$1 = {
3139 name: 'preventOverflow',
3140 enabled: true,
3141 phase: 'main',
3142 fn: preventOverflow,
3143 requiresIfExists: ['offset']
3144 };
3145
3146 function getHTMLElementScroll(element) {
3147 return {
3148 scrollLeft: element.scrollLeft,
3149 scrollTop: element.scrollTop
3150 };
3151 }
3152
3153 function getNodeScroll(node) {
3154 if (node === getWindow(node) || !isHTMLElement(node)) {
3155 return getWindowScroll(node);
3156 } else {
3157 return getHTMLElementScroll(node);
3158 }
3159 }
3160
3161 function isElementScaled(element) {
3162 var rect = element.getBoundingClientRect();
3163 var scaleX = round(rect.width) / element.offsetWidth || 1;
3164 var scaleY = round(rect.height) / element.offsetHeight || 1;
3165 return scaleX !== 1 || scaleY !== 1;
3166 } // Returns the composite rect of an element relative to its offsetParent.
3167 // Composite means it takes into account transforms as well as layout.
3168
3169
3170 function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
3171 if (isFixed === void 0) {
3172 isFixed = false;
3173 }
3174
3175 var isOffsetParentAnElement = isHTMLElement(offsetParent);
3176 var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
3177 var documentElement = getDocumentElement(offsetParent);
3178 var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed);
3179 var scroll = {
3180 scrollLeft: 0,
3181 scrollTop: 0
3182 };
3183 var offsets = {
3184 x: 0,
3185 y: 0
3186 };
3187
3188 if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
3189 if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
3190 isScrollParent(documentElement)) {
3191 scroll = getNodeScroll(offsetParent);
3192 }
3193
3194 if (isHTMLElement(offsetParent)) {
3195 offsets = getBoundingClientRect(offsetParent, true);
3196 offsets.x += offsetParent.clientLeft;
3197 offsets.y += offsetParent.clientTop;
3198 } else if (documentElement) {
3199 offsets.x = getWindowScrollBarX(documentElement);
3200 }
3201 }
3202
3203 return {
3204 x: rect.left + scroll.scrollLeft - offsets.x,
3205 y: rect.top + scroll.scrollTop - offsets.y,
3206 width: rect.width,
3207 height: rect.height
3208 };
3209 }
3210
3211 function order(modifiers) {
3212 var map = new Map();
3213 var visited = new Set();
3214 var result = [];
3215 modifiers.forEach(function (modifier) {
3216 map.set(modifier.name, modifier);
3217 }); // On visiting object, check for its dependencies and visit them recursively
3218
3219 function sort(modifier) {
3220 visited.add(modifier.name);
3221 var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
3222 requires.forEach(function (dep) {
3223 if (!visited.has(dep)) {
3224 var depModifier = map.get(dep);
3225
3226 if (depModifier) {
3227 sort(depModifier);
3228 }
3229 }
3230 });
3231 result.push(modifier);
3232 }
3233
3234 modifiers.forEach(function (modifier) {
3235 if (!visited.has(modifier.name)) {
3236 // check for visited object
3237 sort(modifier);
3238 }
3239 });
3240 return result;
3241 }
3242
3243 function orderModifiers(modifiers) {
3244 // order based on dependencies
3245 var orderedModifiers = order(modifiers); // order based on phase
3246
3247 return modifierPhases.reduce(function (acc, phase) {
3248 return acc.concat(orderedModifiers.filter(function (modifier) {
3249 return modifier.phase === phase;
3250 }));
3251 }, []);
3252 }
3253
3254 function debounce(fn) {
3255 var pending;
3256 return function () {
3257 if (!pending) {
3258 pending = new Promise(function (resolve) {
3259 Promise.resolve().then(function () {
3260 pending = undefined;
3261 resolve(fn());
3262 });
3263 });
3264 }
3265
3266 return pending;
3267 };
3268 }
3269
3270 function mergeByName(modifiers) {
3271 var merged = modifiers.reduce(function (merged, current) {
3272 var existing = merged[current.name];
3273 merged[current.name] = existing ? Object.assign({}, existing, current, {
3274 options: Object.assign({}, existing.options, current.options),
3275 data: Object.assign({}, existing.data, current.data)
3276 }) : current;
3277 return merged;
3278 }, {}); // IE11 does not support Object.values
3279
3280 return Object.keys(merged).map(function (key) {
3281 return merged[key];
3282 });
3283 }
3284
3285 var DEFAULT_OPTIONS = {
3286 placement: 'bottom',
3287 modifiers: [],
3288 strategy: 'absolute'
3289 };
3290
3291 function areValidElements() {
3292 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
3293 args[_key] = arguments[_key];
3294 }
3295
3296 return !args.some(function (element) {
3297 return !(element && typeof element.getBoundingClientRect === 'function');
3298 });
3299 }
3300
3301 function popperGenerator(generatorOptions) {
3302 if (generatorOptions === void 0) {
3303 generatorOptions = {};
3304 }
3305
3306 var _generatorOptions = generatorOptions,
3307 _generatorOptions$def = _generatorOptions.defaultModifiers,
3308 defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def,
3309 _generatorOptions$def2 = _generatorOptions.defaultOptions,
3310 defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
3311 return function createPopper(reference, popper, options) {
3312 if (options === void 0) {
3313 options = defaultOptions;
3314 }
3315
3316 var state = {
3317 placement: 'bottom',
3318 orderedModifiers: [],
3319 options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
3320 modifiersData: {},
3321 elements: {
3322 reference: reference,
3323 popper: popper
3324 },
3325 attributes: {},
3326 styles: {}
3327 };
3328 var effectCleanupFns = [];
3329 var isDestroyed = false;
3330 var instance = {
3331 state: state,
3332 setOptions: function setOptions(setOptionsAction) {
3333 var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction;
3334 cleanupModifierEffects();
3335 state.options = Object.assign({}, defaultOptions, state.options, options);
3336 state.scrollParents = {
3337 reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],
3338 popper: listScrollParents(popper)
3339 }; // Orders the modifiers based on their dependencies and `phase`
3340 // properties
3341
3342 var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers
3343
3344 state.orderedModifiers = orderedModifiers.filter(function (m) {
3345 return m.enabled;
3346 });
3347 runModifierEffects();
3348 return instance.update();
3349 },
3350 // Sync update – it will always be executed, even if not necessary. This
3351 // is useful for low frequency updates where sync behavior simplifies the
3352 // logic.
3353 // For high frequency updates (e.g. `resize` and `scroll` events), always
3354 // prefer the async Popper#update method
3355 forceUpdate: function forceUpdate() {
3356 if (isDestroyed) {
3357 return;
3358 }
3359
3360 var _state$elements = state.elements,
3361 reference = _state$elements.reference,
3362 popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements
3363 // anymore
3364
3365 if (!areValidElements(reference, popper)) {
3366 return;
3367 } // Store the reference and popper rects to be read by modifiers
3368
3369
3370 state.rects = {
3371 reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'),
3372 popper: getLayoutRect(popper)
3373 }; // Modifiers have the ability to reset the current update cycle. The
3374 // most common use case for this is the `flip` modifier changing the
3375 // placement, which then needs to re-run all the modifiers, because the
3376 // logic was previously ran for the previous placement and is therefore
3377 // stale/incorrect
3378
3379 state.reset = false;
3380 state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier
3381 // is filled with the initial data specified by the modifier. This means
3382 // it doesn't persist and is fresh on each update.
3383 // To ensure persistent data, use `${name}#persistent`
3384
3385 state.orderedModifiers.forEach(function (modifier) {
3386 return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
3387 });
3388
3389 for (var index = 0; index < state.orderedModifiers.length; index++) {
3390 if (state.reset === true) {
3391 state.reset = false;
3392 index = -1;
3393 continue;
3394 }
3395
3396 var _state$orderedModifie = state.orderedModifiers[index],
3397 fn = _state$orderedModifie.fn,
3398 _state$orderedModifie2 = _state$orderedModifie.options,
3399 _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2,
3400 name = _state$orderedModifie.name;
3401
3402 if (typeof fn === 'function') {
3403 state = fn({
3404 state: state,
3405 options: _options,
3406 name: name,
3407 instance: instance
3408 }) || state;
3409 }
3410 }
3411 },
3412 // Async and optimistically optimized update – it will not be executed if
3413 // not necessary (debounced to run at most once-per-tick)
3414 update: debounce(function () {
3415 return new Promise(function (resolve) {
3416 instance.forceUpdate();
3417 resolve(state);
3418 });
3419 }),
3420 destroy: function destroy() {
3421 cleanupModifierEffects();
3422 isDestroyed = true;
3423 }
3424 };
3425
3426 if (!areValidElements(reference, popper)) {
3427 return instance;
3428 }
3429
3430 instance.setOptions(options).then(function (state) {
3431 if (!isDestroyed && options.onFirstUpdate) {
3432 options.onFirstUpdate(state);
3433 }
3434 }); // Modifiers have the ability to execute arbitrary code before the first
3435 // update cycle runs. They will be executed in the same order as the update
3436 // cycle. This is useful when a modifier adds some persistent data that
3437 // other modifiers need to use, but the modifier is run after the dependent
3438 // one.
3439
3440 function runModifierEffects() {
3441 state.orderedModifiers.forEach(function (_ref) {
3442 var name = _ref.name,
3443 _ref$options = _ref.options,
3444 options = _ref$options === void 0 ? {} : _ref$options,
3445 effect = _ref.effect;
3446
3447 if (typeof effect === 'function') {
3448 var cleanupFn = effect({
3449 state: state,
3450 name: name,
3451 instance: instance,
3452 options: options
3453 });
3454
3455 var noopFn = function noopFn() {};
3456
3457 effectCleanupFns.push(cleanupFn || noopFn);
3458 }
3459 });
3460 }
3461
3462 function cleanupModifierEffects() {
3463 effectCleanupFns.forEach(function (fn) {
3464 return fn();
3465 });
3466 effectCleanupFns = [];
3467 }
3468
3469 return instance;
3470 };
3471 }
3472 var createPopper$2 = /*#__PURE__*/popperGenerator(); // eslint-disable-next-line import/no-unused-modules
3473
3474 var defaultModifiers$1 = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1];
3475 var createPopper$1 = /*#__PURE__*/popperGenerator({
3476 defaultModifiers: defaultModifiers$1
3477 }); // eslint-disable-next-line import/no-unused-modules
3478
3479 var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1];
3480 var createPopper = /*#__PURE__*/popperGenerator({
3481 defaultModifiers: defaultModifiers
3482 }); // eslint-disable-next-line import/no-unused-modules
3483
3484 const Popper = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
3485 __proto__: null,
3486 afterMain,
3487 afterRead,
3488 afterWrite,
3489 applyStyles: applyStyles$1,
3490 arrow: arrow$1,
3491 auto,
3492 basePlacements,
3493 beforeMain,
3494 beforeRead,
3495 beforeWrite,
3496 bottom,
3497 clippingParents,
3498 computeStyles: computeStyles$1,
3499 createPopper,
3500 createPopperBase: createPopper$2,
3501 createPopperLite: createPopper$1,
3502 detectOverflow,
3503 end,
3504 eventListeners,
3505 flip: flip$1,
3506 hide: hide$1,
3507 left,
3508 main,
3509 modifierPhases,
3510 offset: offset$1,
3511 placements,
3512 popper,
3513 popperGenerator,
3514 popperOffsets: popperOffsets$1,
3515 preventOverflow: preventOverflow$1,
3516 read,
3517 reference,
3518 right,
3519 start,
3520 top,
3521 variationPlacements,
3522 viewport,
3523 write
3524 }, Symbol.toStringTag, { value: 'Module' }));
3525
3526 /**
3527 * --------------------------------------------------------------------------
3528 * Bootstrap dropdown.js
3529 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
3530 * --------------------------------------------------------------------------
3531 */
3532
3533
3534 /**
3535 * Constants
3536 */
3537
3538 const NAME$a = 'dropdown';
3539 const DATA_KEY$6 = 'bs.dropdown';
3540 const EVENT_KEY$6 = `.${DATA_KEY$6}`;
3541 const DATA_API_KEY$3 = '.data-api';
3542 const ESCAPE_KEY$2 = 'Escape';
3543 const TAB_KEY$1 = 'Tab';
3544 const ARROW_UP_KEY$1 = 'ArrowUp';
3545 const ARROW_DOWN_KEY$1 = 'ArrowDown';
3546 const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button
3547
3548 const EVENT_HIDE$5 = `hide${EVENT_KEY$6}`;
3549 const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$6}`;
3550 const EVENT_SHOW$5 = `show${EVENT_KEY$6}`;
3551 const EVENT_SHOWN$5 = `shown${EVENT_KEY$6}`;
3552 const EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`;
3553 const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$6}${DATA_API_KEY$3}`;
3554 const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$6}${DATA_API_KEY$3}`;
3555 const CLASS_NAME_SHOW$6 = 'show';
3556 const CLASS_NAME_DROPUP = 'dropup';
3557 const CLASS_NAME_DROPEND = 'dropend';
3558 const CLASS_NAME_DROPSTART = 'dropstart';
3559 const CLASS_NAME_DROPUP_CENTER = 'dropup-center';
3560 const CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center';
3561 const SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)';
3562 const SELECTOR_DATA_TOGGLE_SHOWN = `${SELECTOR_DATA_TOGGLE$3}.${CLASS_NAME_SHOW$6}`;
3563 const SELECTOR_MENU = '.dropdown-menu';
3564 const SELECTOR_NAVBAR = '.navbar';
3565 const SELECTOR_NAVBAR_NAV = '.navbar-nav';
3566 const SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)';
3567 const PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start';
3568 const PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end';
3569 const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start';
3570 const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';
3571 const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';
3572 const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';
3573 const PLACEMENT_TOPCENTER = 'top';
3574 const PLACEMENT_BOTTOMCENTER = 'bottom';
3575 const Default$9 = {
3576 autoClose: true,
3577 boundary: 'clippingParents',
3578 display: 'dynamic',
3579 offset: [0, 2],
3580 popperConfig: null,
3581 reference: 'toggle'
3582 };
3583 const DefaultType$9 = {
3584 autoClose: '(boolean|string)',
3585 boundary: '(string|element)',
3586 display: 'string',
3587 offset: '(array|string|function)',
3588 popperConfig: '(null|object|function)',
3589 reference: '(string|element|object)'
3590 };
3591
3592 /**
3593 * Class definition
3594 */
3595
3596 class Dropdown extends BaseComponent {
3597 constructor(element, config) {
3598 super(element, config);
3599 this._popper = null;
3600 this._parent = this._element.parentNode; // dropdown wrapper
3601 // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/
3602 this._menu = SelectorEngine.next(this._element, SELECTOR_MENU)[0] || SelectorEngine.prev(this._element, SELECTOR_MENU)[0] || SelectorEngine.findOne(SELECTOR_MENU, this._parent);
3603 this._inNavbar = this._detectNavbar();
3604 }
3605
3606 // Getters
3607 static get Default() {
3608 return Default$9;
3609 }
3610 static get DefaultType() {
3611 return DefaultType$9;
3612 }
3613 static get NAME() {
3614 return NAME$a;
3615 }
3616
3617 // Public
3618 toggle() {
3619 return this._isShown() ? this.hide() : this.show();
3620 }
3621 show() {
3622 if (isDisabled(this._element) || this._isShown()) {
3623 return;
3624 }
3625 const relatedTarget = {
3626 relatedTarget: this._element
3627 };
3628 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$5, relatedTarget);
3629 if (showEvent.defaultPrevented) {
3630 return;
3631 }
3632 this._createPopper();
3633
3634 // If this is a touch-enabled device we add extra
3635 // empty mouseover listeners to the body's immediate children;
3636 // only needed because of broken event delegation on iOS
3637 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
3638 if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) {
3639 for (const element of [].concat(...document.body.children)) {
3640 EventHandler.on(element, 'mouseover', noop);
3641 }
3642 }
3643 this._element.focus();
3644 this._element.setAttribute('aria-expanded', true);
3645 this._menu.classList.add(CLASS_NAME_SHOW$6);
3646 this._element.classList.add(CLASS_NAME_SHOW$6);
3647 EventHandler.trigger(this._element, EVENT_SHOWN$5, relatedTarget);
3648 }
3649 hide() {
3650 if (isDisabled(this._element) || !this._isShown()) {
3651 return;
3652 }
3653 const relatedTarget = {
3654 relatedTarget: this._element
3655 };
3656 this._completeHide(relatedTarget);
3657 }
3658 dispose() {
3659 if (this._popper) {
3660 this._popper.destroy();
3661 }
3662 super.dispose();
3663 }
3664 update() {
3665 this._inNavbar = this._detectNavbar();
3666 if (this._popper) {
3667 this._popper.update();
3668 }
3669 }
3670
3671 // Private
3672 _completeHide(relatedTarget) {
3673 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$5, relatedTarget);
3674 if (hideEvent.defaultPrevented) {
3675 return;
3676 }
3677
3678 // If this is a touch-enabled device we remove the extra
3679 // empty mouseover listeners we added for iOS support
3680 if ('ontouchstart' in document.documentElement) {
3681 for (const element of [].concat(...document.body.children)) {
3682 EventHandler.off(element, 'mouseover', noop);
3683 }
3684 }
3685 if (this._popper) {
3686 this._popper.destroy();
3687 }
3688 this._menu.classList.remove(CLASS_NAME_SHOW$6);
3689 this._element.classList.remove(CLASS_NAME_SHOW$6);
3690 this._element.setAttribute('aria-expanded', 'false');
3691 Manipulator.removeDataAttribute(this._menu, 'popper');
3692 EventHandler.trigger(this._element, EVENT_HIDDEN$5, relatedTarget);
3693 }
3694 _getConfig(config) {
3695 config = super._getConfig(config);
3696 if (typeof config.reference === 'object' && !isElement$1(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') {
3697 // Popper virtual elements require a getBoundingClientRect method
3698 throw new TypeError(`${NAME$a.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);
3699 }
3700 return config;
3701 }
3702 _createPopper() {
3703 if (typeof Popper === 'undefined') {
3704 throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)');
3705 }
3706 let referenceElement = this._element;
3707 if (this._config.reference === 'parent') {
3708 referenceElement = this._parent;
3709 } else if (isElement$1(this._config.reference)) {
3710 referenceElement = getElement(this._config.reference);
3711 } else if (typeof this._config.reference === 'object') {
3712 referenceElement = this._config.reference;
3713 }
3714 const popperConfig = this._getPopperConfig();
3715 this._popper = createPopper(referenceElement, this._menu, popperConfig);
3716 }
3717 _isShown() {
3718 return this._menu.classList.contains(CLASS_NAME_SHOW$6);
3719 }
3720 _getPlacement() {
3721 const parentDropdown = this._parent;
3722 if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
3723 return PLACEMENT_RIGHT;
3724 }
3725 if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {
3726 return PLACEMENT_LEFT;
3727 }
3728 if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) {
3729 return PLACEMENT_TOPCENTER;
3730 }
3731 if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENTER)) {
3732 return PLACEMENT_BOTTOMCENTER;
3733 }
3734
3735 // We need to trim the value because custom properties can also include spaces
3736 const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end';
3737 if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {
3738 return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;
3739 }
3740 return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;
3741 }
3742 _detectNavbar() {
3743 return this._element.closest(SELECTOR_NAVBAR) !== null;
3744 }
3745 _getOffset() {
3746 const {
3747 offset
3748 } = this._config;
3749 if (typeof offset === 'string') {
3750 return offset.split(',').map(value => Number.parseInt(value, 10));
3751 }
3752 if (typeof offset === 'function') {
3753 return popperData => offset(popperData, this._element);
3754 }
3755 return offset;
3756 }
3757 _getPopperConfig() {
3758 const defaultBsPopperConfig = {
3759 placement: this._getPlacement(),
3760 modifiers: [{
3761 name: 'preventOverflow',
3762 options: {
3763 boundary: this._config.boundary
3764 }
3765 }, {
3766 name: 'offset',
3767 options: {
3768 offset: this._getOffset()
3769 }
3770 }]
3771 };
3772
3773 // Disable Popper if we have a static display or Dropdown is in Navbar
3774 if (this._inNavbar || this._config.display === 'static') {
3775 Manipulator.setDataAttribute(this._menu, 'popper', 'static'); // TODO: v6 remove
3776 defaultBsPopperConfig.modifiers = [{
3777 name: 'applyStyles',
3778 enabled: false
3779 }];
3780 }
3781 return {
3782 ...defaultBsPopperConfig,
3783 ...execute(this._config.popperConfig, [defaultBsPopperConfig])
3784 };
3785 }
3786 _selectMenuItem({
3787 key,
3788 target
3789 }) {
3790 const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(element => isVisible(element));
3791 if (!items.length) {
3792 return;
3793 }
3794
3795 // if target isn't included in items (e.g. when expanding the dropdown)
3796 // allow cycling to get the last item in case key equals ARROW_UP_KEY
3797 getNextActiveElement(items, target, key === ARROW_DOWN_KEY$1, !items.includes(target)).focus();
3798 }
3799
3800 // Static
3801 static jQueryInterface(config) {
3802 return this.each(function () {
3803 const data = Dropdown.getOrCreateInstance(this, config);
3804 if (typeof config !== 'string') {
3805 return;
3806 }
3807 if (typeof data[config] === 'undefined') {
3808 throw new TypeError(`No method named "${config}"`);
3809 }
3810 data[config]();
3811 });
3812 }
3813 static clearMenus(event) {
3814 if (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1) {
3815 return;
3816 }
3817 const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN);
3818 for (const toggle of openToggles) {
3819 const context = Dropdown.getInstance(toggle);
3820 if (!context || context._config.autoClose === false) {
3821 continue;
3822 }
3823 const composedPath = event.composedPath();
3824 const isMenuTarget = composedPath.includes(context._menu);
3825 if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) {
3826 continue;
3827 }
3828
3829 // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu
3830 if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) {
3831 continue;
3832 }
3833 const relatedTarget = {
3834 relatedTarget: context._element
3835 };
3836 if (event.type === 'click') {
3837 relatedTarget.clickEvent = event;
3838 }
3839 context._completeHide(relatedTarget);
3840 }
3841 }
3842 static dataApiKeydownHandler(event) {
3843 // If not an UP | DOWN | ESCAPE key => not a dropdown command
3844 // If input/textarea && if key is other than ESCAPE => not a dropdown command
3845
3846 const isInput = /input|textarea/i.test(event.target.tagName);
3847 const isEscapeEvent = event.key === ESCAPE_KEY$2;
3848 const isUpOrDownEvent = [ARROW_UP_KEY$1, ARROW_DOWN_KEY$1].includes(event.key);
3849 if (!isUpOrDownEvent && !isEscapeEvent) {
3850 return;
3851 }
3852 if (isInput && !isEscapeEvent) {
3853 return;
3854 }
3855 event.preventDefault();
3856
3857 // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/
3858 const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.next(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.findOne(SELECTOR_DATA_TOGGLE$3, event.delegateTarget.parentNode);
3859 const instance = Dropdown.getOrCreateInstance(getToggleButton);
3860 if (isUpOrDownEvent) {
3861 event.stopPropagation();
3862 instance.show();
3863 instance._selectMenuItem(event);
3864 return;
3865 }
3866 if (instance._isShown()) {
3867 // else is escape and we check if it is shown
3868 event.stopPropagation();
3869 instance.hide();
3870 getToggleButton.focus();
3871 }
3872 }
3873 }
3874
3875 /**
3876 * Data API implementation
3877 */
3878
3879 EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler);
3880 EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler);
3881 EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus);
3882 EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);
3883 EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) {
3884 event.preventDefault();
3885 Dropdown.getOrCreateInstance(this).toggle();
3886 });
3887
3888 /**
3889 * jQuery
3890 */
3891
3892 defineJQueryPlugin(Dropdown);
3893
3894 /**
3895 * --------------------------------------------------------------------------
3896 * Bootstrap util/backdrop.js
3897 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
3898 * --------------------------------------------------------------------------
3899 */
3900
3901
3902 /**
3903 * Constants
3904 */
3905
3906 const NAME$9 = 'backdrop';
3907 const CLASS_NAME_FADE$4 = 'fade';
3908 const CLASS_NAME_SHOW$5 = 'show';
3909 const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$9}`;
3910 const Default$8 = {
3911 className: 'modal-backdrop',
3912 clickCallback: null,
3913 isAnimated: false,
3914 isVisible: true,
3915 // if false, we use the backdrop helper without adding any element to the dom
3916 rootElement: 'body' // give the choice to place backdrop under different elements
3917 };
3918 const DefaultType$8 = {
3919 className: 'string',
3920 clickCallback: '(function|null)',
3921 isAnimated: 'boolean',
3922 isVisible: 'boolean',
3923 rootElement: '(element|string)'
3924 };
3925
3926 /**
3927 * Class definition
3928 */
3929
3930 class Backdrop extends Config {
3931 constructor(config) {
3932 super();
3933 this._config = this._getConfig(config);
3934 this._isAppended = false;
3935 this._element = null;
3936 }
3937
3938 // Getters
3939 static get Default() {
3940 return Default$8;
3941 }
3942 static get DefaultType() {
3943 return DefaultType$8;
3944 }
3945 static get NAME() {
3946 return NAME$9;
3947 }
3948
3949 // Public
3950 show(callback) {
3951 if (!this._config.isVisible) {
3952 execute(callback);
3953 return;
3954 }
3955 this._append();
3956 const element = this._getElement();
3957 if (this._config.isAnimated) {
3958 reflow(element);
3959 }
3960 element.classList.add(CLASS_NAME_SHOW$5);
3961 this._emulateAnimation(() => {
3962 execute(callback);
3963 });
3964 }
3965 hide(callback) {
3966 if (!this._config.isVisible) {
3967 execute(callback);
3968 return;
3969 }
3970 this._getElement().classList.remove(CLASS_NAME_SHOW$5);
3971 this._emulateAnimation(() => {
3972 this.dispose();
3973 execute(callback);
3974 });
3975 }
3976 dispose() {
3977 if (!this._isAppended) {
3978 return;
3979 }
3980 EventHandler.off(this._element, EVENT_MOUSEDOWN);
3981 this._element.remove();
3982 this._isAppended = false;
3983 }
3984
3985 // Private
3986 _getElement() {
3987 if (!this._element) {
3988 const backdrop = document.createElement('div');
3989 backdrop.className = this._config.className;
3990 if (this._config.isAnimated) {
3991 backdrop.classList.add(CLASS_NAME_FADE$4);
3992 }
3993 this._element = backdrop;
3994 }
3995 return this._element;
3996 }
3997 _configAfterMerge(config) {
3998 // use getElement() with the default "body" to get a fresh Element on each instantiation
3999 config.rootElement = getElement(config.rootElement);
4000 return config;
4001 }
4002 _append() {
4003 if (this._isAppended) {
4004 return;
4005 }
4006 const element = this._getElement();
4007 this._config.rootElement.append(element);
4008 EventHandler.on(element, EVENT_MOUSEDOWN, () => {
4009 execute(this._config.clickCallback);
4010 });
4011 this._isAppended = true;
4012 }
4013 _emulateAnimation(callback) {
4014 executeAfterTransition(callback, this._getElement(), this._config.isAnimated);
4015 }
4016 }
4017
4018 /**
4019 * --------------------------------------------------------------------------
4020 * Bootstrap util/focustrap.js
4021 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
4022 * --------------------------------------------------------------------------
4023 */
4024
4025
4026 /**
4027 * Constants
4028 */
4029
4030 const NAME$8 = 'focustrap';
4031 const DATA_KEY$5 = 'bs.focustrap';
4032 const EVENT_KEY$5 = `.${DATA_KEY$5}`;
4033 const EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$5}`;
4034 const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$5}`;
4035 const TAB_KEY = 'Tab';
4036 const TAB_NAV_FORWARD = 'forward';
4037 const TAB_NAV_BACKWARD = 'backward';
4038 const Default$7 = {
4039 autofocus: true,
4040 trapElement: null // The element to trap focus inside of
4041 };
4042 const DefaultType$7 = {
4043 autofocus: 'boolean',
4044 trapElement: 'element'
4045 };
4046
4047 /**
4048 * Class definition
4049 */
4050
4051 class FocusTrap extends Config {
4052 constructor(config) {
4053 super();
4054 this._config = this._getConfig(config);
4055 this._isActive = false;
4056 this._lastTabNavDirection = null;
4057 }
4058
4059 // Getters
4060 static get Default() {
4061 return Default$7;
4062 }
4063 static get DefaultType() {
4064 return DefaultType$7;
4065 }
4066 static get NAME() {
4067 return NAME$8;
4068 }
4069
4070 // Public
4071 activate() {
4072 if (this._isActive) {
4073 return;
4074 }
4075 if (this._config.autofocus) {
4076 this._config.trapElement.focus();
4077 }
4078 EventHandler.off(document, EVENT_KEY$5); // guard against infinite focus loop
4079 EventHandler.on(document, EVENT_FOCUSIN$2, event => this._handleFocusin(event));
4080 EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event));
4081 this._isActive = true;
4082 }
4083 deactivate() {
4084 if (!this._isActive) {
4085 return;
4086 }
4087 this._isActive = false;
4088 EventHandler.off(document, EVENT_KEY$5);
4089 }
4090
4091 // Private
4092 _handleFocusin(event) {
4093 const {
4094 trapElement
4095 } = this._config;
4096 if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) {
4097 return;
4098 }
4099 const elements = SelectorEngine.focusableChildren(trapElement);
4100 if (elements.length === 0) {
4101 trapElement.focus();
4102 } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {
4103 elements[elements.length - 1].focus();
4104 } else {
4105 elements[0].focus();
4106 }
4107 }
4108 _handleKeydown(event) {
4109 if (event.key !== TAB_KEY) {
4110 return;
4111 }
4112 this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD;
4113 }
4114 }
4115
4116 /**
4117 * --------------------------------------------------------------------------
4118 * Bootstrap util/scrollBar.js
4119 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
4120 * --------------------------------------------------------------------------
4121 */
4122
4123
4124 /**
4125 * Constants
4126 */
4127
4128 const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
4129 const SELECTOR_STICKY_CONTENT = '.sticky-top';
4130 const PROPERTY_PADDING = 'padding-right';
4131 const PROPERTY_MARGIN = 'margin-right';
4132
4133 /**
4134 * Class definition
4135 */
4136
4137 class ScrollBarHelper {
4138 constructor() {
4139 this._element = document.body;
4140 }
4141
4142 // Public
4143 getWidth() {
4144 // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
4145 const documentWidth = document.documentElement.clientWidth;
4146 return Math.abs(window.innerWidth - documentWidth);
4147 }
4148 hide() {
4149 const width = this.getWidth();
4150 this._disableOverFlow();
4151 // give padding to element to balance the hidden scrollbar width
4152 this._setElementAttributes(this._element, PROPERTY_PADDING, calculatedValue => calculatedValue + width);
4153 // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
4154 this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, calculatedValue => calculatedValue + width);
4155 this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, calculatedValue => calculatedValue - width);
4156 }
4157 reset() {
4158 this._resetElementAttributes(this._element, 'overflow');
4159 this._resetElementAttributes(this._element, PROPERTY_PADDING);
4160 this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING);
4161 this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN);
4162 }
4163 isOverflowing() {
4164 return this.getWidth() > 0;
4165 }
4166
4167 // Private
4168 _disableOverFlow() {
4169 this._saveInitialAttribute(this._element, 'overflow');
4170 this._element.style.overflow = 'hidden';
4171 }
4172 _setElementAttributes(selector, styleProperty, callback) {
4173 const scrollbarWidth = this.getWidth();
4174 const manipulationCallBack = element => {
4175 if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
4176 return;
4177 }
4178 this._saveInitialAttribute(element, styleProperty);
4179 const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty);
4180 element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`);
4181 };
4182 this._applyManipulationCallback(selector, manipulationCallBack);
4183 }
4184 _saveInitialAttribute(element, styleProperty) {
4185 const actualValue = element.style.getPropertyValue(styleProperty);
4186 if (actualValue) {
4187 Manipulator.setDataAttribute(element, styleProperty, actualValue);
4188 }
4189 }
4190 _resetElementAttributes(selector, styleProperty) {
4191 const manipulationCallBack = element => {
4192 const value = Manipulator.getDataAttribute(element, styleProperty);
4193 // We only want to remove the property if the value is `null`; the value can also be zero
4194 if (value === null) {
4195 element.style.removeProperty(styleProperty);
4196 return;
4197 }
4198 Manipulator.removeDataAttribute(element, styleProperty);
4199 element.style.setProperty(styleProperty, value);
4200 };
4201 this._applyManipulationCallback(selector, manipulationCallBack);
4202 }
4203 _applyManipulationCallback(selector, callBack) {
4204 if (isElement$1(selector)) {
4205 callBack(selector);
4206 return;
4207 }
4208 for (const sel of SelectorEngine.find(selector, this._element)) {
4209 callBack(sel);
4210 }
4211 }
4212 }
4213
4214 /**
4215 * --------------------------------------------------------------------------
4216 * Bootstrap modal.js
4217 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
4218 * --------------------------------------------------------------------------
4219 */
4220
4221
4222 /**
4223 * Constants
4224 */
4225
4226 const NAME$7 = 'modal';
4227 const DATA_KEY$4 = 'bs.modal';
4228 const EVENT_KEY$4 = `.${DATA_KEY$4}`;
4229 const DATA_API_KEY$2 = '.data-api';
4230 const ESCAPE_KEY$1 = 'Escape';
4231 const EVENT_HIDE$4 = `hide${EVENT_KEY$4}`;
4232 const EVENT_HIDE_PREVENTED$1 = `hidePrevented${EVENT_KEY$4}`;
4233 const EVENT_HIDDEN$4 = `hidden${EVENT_KEY$4}`;
4234 const EVENT_SHOW$4 = `show${EVENT_KEY$4}`;
4235 const EVENT_SHOWN$4 = `shown${EVENT_KEY$4}`;
4236 const EVENT_RESIZE$1 = `resize${EVENT_KEY$4}`;
4237 const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY$4}`;
4238 const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$4}`;
4239 const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$4}`;
4240 const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$4}${DATA_API_KEY$2}`;
4241 const CLASS_NAME_OPEN = 'modal-open';
4242 const CLASS_NAME_FADE$3 = 'fade';
4243 const CLASS_NAME_SHOW$4 = 'show';
4244 const CLASS_NAME_STATIC = 'modal-static';
4245 const OPEN_SELECTOR$1 = '.modal.show';
4246 const SELECTOR_DIALOG = '.modal-dialog';
4247 const SELECTOR_MODAL_BODY = '.modal-body';
4248 const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]';
4249 const Default$6 = {
4250 backdrop: true,
4251 focus: true,
4252 keyboard: true
4253 };
4254 const DefaultType$6 = {
4255 backdrop: '(boolean|string)',
4256 focus: 'boolean',
4257 keyboard: 'boolean'
4258 };
4259
4260 /**
4261 * Class definition
4262 */
4263
4264 class Modal extends BaseComponent {
4265 constructor(element, config) {
4266 super(element, config);
4267 this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element);
4268 this._backdrop = this._initializeBackDrop();
4269 this._focustrap = this._initializeFocusTrap();
4270 this._isShown = false;
4271 this._isTransitioning = false;
4272 this._scrollBar = new ScrollBarHelper();
4273 this._addEventListeners();
4274 }
4275
4276 // Getters
4277 static get Default() {
4278 return Default$6;
4279 }
4280 static get DefaultType() {
4281 return DefaultType$6;
4282 }
4283 static get NAME() {
4284 return NAME$7;
4285 }
4286
4287 // Public
4288 toggle(relatedTarget) {
4289 return this._isShown ? this.hide() : this.show(relatedTarget);
4290 }
4291 show(relatedTarget) {
4292 if (this._isShown || this._isTransitioning) {
4293 return;
4294 }
4295 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, {
4296 relatedTarget
4297 });
4298 if (showEvent.defaultPrevented) {
4299 return;
4300 }
4301 this._isShown = true;
4302 this._isTransitioning = true;
4303 this._scrollBar.hide();
4304 document.body.classList.add(CLASS_NAME_OPEN);
4305 this._adjustDialog();
4306 this._backdrop.show(() => this._showElement(relatedTarget));
4307 }
4308 hide() {
4309 if (!this._isShown || this._isTransitioning) {
4310 return;
4311 }
4312 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4);
4313 if (hideEvent.defaultPrevented) {
4314 return;
4315 }
4316 this._isShown = false;
4317 this._isTransitioning = true;
4318 this._focustrap.deactivate();
4319 this._element.classList.remove(CLASS_NAME_SHOW$4);
4320 this._queueCallback(() => this._hideModal(), this._element, this._isAnimated());
4321 }
4322 dispose() {
4323 EventHandler.off(window, EVENT_KEY$4);
4324 EventHandler.off(this._dialog, EVENT_KEY$4);
4325 this._backdrop.dispose();
4326 this._focustrap.deactivate();
4327 super.dispose();
4328 }
4329 handleUpdate() {
4330 this._adjustDialog();
4331 }
4332
4333 // Private
4334 _initializeBackDrop() {
4335 return new Backdrop({
4336 isVisible: Boolean(this._config.backdrop),
4337 // 'static' option will be translated to true, and booleans will keep their value,
4338 isAnimated: this._isAnimated()
4339 });
4340 }
4341 _initializeFocusTrap() {
4342 return new FocusTrap({
4343 trapElement: this._element
4344 });
4345 }
4346 _showElement(relatedTarget) {
4347 // try to append dynamic modal
4348 if (!document.body.contains(this._element)) {
4349 document.body.append(this._element);
4350 }
4351 this._element.style.display = 'block';
4352 this._element.removeAttribute('aria-hidden');
4353 this._element.setAttribute('aria-modal', true);
4354 this._element.setAttribute('role', 'dialog');
4355 this._element.scrollTop = 0;
4356 const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);
4357 if (modalBody) {
4358 modalBody.scrollTop = 0;
4359 }
4360 reflow(this._element);
4361 this._element.classList.add(CLASS_NAME_SHOW$4);
4362 const transitionComplete = () => {
4363 if (this._config.focus) {
4364 this._focustrap.activate();
4365 }
4366 this._isTransitioning = false;
4367 EventHandler.trigger(this._element, EVENT_SHOWN$4, {
4368 relatedTarget
4369 });
4370 };
4371 this._queueCallback(transitionComplete, this._dialog, this._isAnimated());
4372 }
4373 _addEventListeners() {
4374 EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => {
4375 if (event.key !== ESCAPE_KEY$1) {
4376 return;
4377 }
4378 if (this._config.keyboard) {
4379 this.hide();
4380 return;
4381 }
4382 this._triggerBackdropTransition();
4383 });
4384 EventHandler.on(window, EVENT_RESIZE$1, () => {
4385 if (this._isShown && !this._isTransitioning) {
4386 this._adjustDialog();
4387 }
4388 });
4389 EventHandler.on(this._element, EVENT_MOUSEDOWN_DISMISS, event => {
4390 // a bad trick to segregate clicks that may start inside dialog but end outside, and avoid listen to scrollbar clicks
4391 EventHandler.one(this._element, EVENT_CLICK_DISMISS, event2 => {
4392 if (this._element !== event.target || this._element !== event2.target) {
4393 return;
4394 }
4395 if (this._config.backdrop === 'static') {
4396 this._triggerBackdropTransition();
4397 return;
4398 }
4399 if (this._config.backdrop) {
4400 this.hide();
4401 }
4402 });
4403 });
4404 }
4405 _hideModal() {
4406 this._element.style.display = 'none';
4407 this._element.setAttribute('aria-hidden', true);
4408 this._element.removeAttribute('aria-modal');
4409 this._element.removeAttribute('role');
4410 this._isTransitioning = false;
4411 this._backdrop.hide(() => {
4412 document.body.classList.remove(CLASS_NAME_OPEN);
4413 this._resetAdjustments();
4414 this._scrollBar.reset();
4415 EventHandler.trigger(this._element, EVENT_HIDDEN$4);
4416 });
4417 }
4418 _isAnimated() {
4419 return this._element.classList.contains(CLASS_NAME_FADE$3);
4420 }
4421 _triggerBackdropTransition() {
4422 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED$1);
4423 if (hideEvent.defaultPrevented) {
4424 return;
4425 }
4426 const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
4427 const initialOverflowY = this._element.style.overflowY;
4428 // return if the following background transition hasn't yet completed
4429 if (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) {
4430 return;
4431 }
4432 if (!isModalOverflowing) {
4433 this._element.style.overflowY = 'hidden';
4434 }
4435 this._element.classList.add(CLASS_NAME_STATIC);
4436 this._queueCallback(() => {
4437 this._element.classList.remove(CLASS_NAME_STATIC);
4438 this._queueCallback(() => {
4439 this._element.style.overflowY = initialOverflowY;
4440 }, this._dialog);
4441 }, this._dialog);
4442 this._element.focus();
4443 }
4444
4445 /**
4446 * The following methods are used to handle overflowing modals
4447 */
4448
4449 _adjustDialog() {
4450 const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
4451 const scrollbarWidth = this._scrollBar.getWidth();
4452 const isBodyOverflowing = scrollbarWidth > 0;
4453 if (isBodyOverflowing && !isModalOverflowing) {
4454 const property = isRTL() ? 'paddingLeft' : 'paddingRight';
4455 this._element.style[property] = `${scrollbarWidth}px`;
4456 }
4457 if (!isBodyOverflowing && isModalOverflowing) {
4458 const property = isRTL() ? 'paddingRight' : 'paddingLeft';
4459 this._element.style[property] = `${scrollbarWidth}px`;
4460 }
4461 }
4462 _resetAdjustments() {
4463 this._element.style.paddingLeft = '';
4464 this._element.style.paddingRight = '';
4465 }
4466
4467 // Static
4468 static jQueryInterface(config, relatedTarget) {
4469 return this.each(function () {
4470 const data = Modal.getOrCreateInstance(this, config);
4471 if (typeof config !== 'string') {
4472 return;
4473 }
4474 if (typeof data[config] === 'undefined') {
4475 throw new TypeError(`No method named "${config}"`);
4476 }
4477 data[config](relatedTarget);
4478 });
4479 }
4480 }
4481
4482 /**
4483 * Data API implementation
4484 */
4485
4486 EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) {
4487 const target = SelectorEngine.getElementFromSelector(this);
4488 if (['A', 'AREA'].includes(this.tagName)) {
4489 event.preventDefault();
4490 }
4491 EventHandler.one(target, EVENT_SHOW$4, showEvent => {
4492 if (showEvent.defaultPrevented) {
4493 // only register focus restorer if modal will actually get shown
4494 return;
4495 }
4496 EventHandler.one(target, EVENT_HIDDEN$4, () => {
4497 if (isVisible(this)) {
4498 this.focus();
4499 }
4500 });
4501 });
4502
4503 // avoid conflict when clicking modal toggler while another one is open
4504 const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1);
4505 if (alreadyOpen) {
4506 Modal.getInstance(alreadyOpen).hide();
4507 }
4508 const data = Modal.getOrCreateInstance(target);
4509 data.toggle(this);
4510 });
4511 enableDismissTrigger(Modal);
4512
4513 /**
4514 * jQuery
4515 */
4516
4517 defineJQueryPlugin(Modal);
4518
4519 /**
4520 * --------------------------------------------------------------------------
4521 * Bootstrap offcanvas.js
4522 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
4523 * --------------------------------------------------------------------------
4524 */
4525
4526
4527 /**
4528 * Constants
4529 */
4530
4531 const NAME$6 = 'offcanvas';
4532 const DATA_KEY$3 = 'bs.offcanvas';
4533 const EVENT_KEY$3 = `.${DATA_KEY$3}`;
4534 const DATA_API_KEY$1 = '.data-api';
4535 const EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$3}${DATA_API_KEY$1}`;
4536 const ESCAPE_KEY = 'Escape';
4537 const CLASS_NAME_SHOW$3 = 'show';
4538 const CLASS_NAME_SHOWING$1 = 'showing';
4539 const CLASS_NAME_HIDING = 'hiding';
4540 const CLASS_NAME_BACKDROP = 'offcanvas-backdrop';
4541 const OPEN_SELECTOR = '.offcanvas.show';
4542 const EVENT_SHOW$3 = `show${EVENT_KEY$3}`;
4543 const EVENT_SHOWN$3 = `shown${EVENT_KEY$3}`;
4544 const EVENT_HIDE$3 = `hide${EVENT_KEY$3}`;
4545 const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$3}`;
4546 const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$3}`;
4547 const EVENT_RESIZE = `resize${EVENT_KEY$3}`;
4548 const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$3}${DATA_API_KEY$1}`;
4549 const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$3}`;
4550 const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]';
4551 const Default$5 = {
4552 backdrop: true,
4553 keyboard: true,
4554 scroll: false
4555 };
4556 const DefaultType$5 = {
4557 backdrop: '(boolean|string)',
4558 keyboard: 'boolean',
4559 scroll: 'boolean'
4560 };
4561
4562 /**
4563 * Class definition
4564 */
4565
4566 class Offcanvas extends BaseComponent {
4567 constructor(element, config) {
4568 super(element, config);
4569 this._isShown = false;
4570 this._backdrop = this._initializeBackDrop();
4571 this._focustrap = this._initializeFocusTrap();
4572 this._addEventListeners();
4573 }
4574
4575 // Getters
4576 static get Default() {
4577 return Default$5;
4578 }
4579 static get DefaultType() {
4580 return DefaultType$5;
4581 }
4582 static get NAME() {
4583 return NAME$6;
4584 }
4585
4586 // Public
4587 toggle(relatedTarget) {
4588 return this._isShown ? this.hide() : this.show(relatedTarget);
4589 }
4590 show(relatedTarget) {
4591 if (this._isShown) {
4592 return;
4593 }
4594 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {
4595 relatedTarget
4596 });
4597 if (showEvent.defaultPrevented) {
4598 return;
4599 }
4600 this._isShown = true;
4601 this._backdrop.show();
4602 if (!this._config.scroll) {
4603 new ScrollBarHelper().hide();
4604 }
4605 this._element.setAttribute('aria-modal', true);
4606 this._element.setAttribute('role', 'dialog');
4607 this._element.classList.add(CLASS_NAME_SHOWING$1);
4608 const completeCallBack = () => {
4609 if (!this._config.scroll || this._config.backdrop) {
4610 this._focustrap.activate();
4611 }
4612 this._element.classList.add(CLASS_NAME_SHOW$3);
4613 this._element.classList.remove(CLASS_NAME_SHOWING$1);
4614 EventHandler.trigger(this._element, EVENT_SHOWN$3, {
4615 relatedTarget
4616 });
4617 };
4618 this._queueCallback(completeCallBack, this._element, true);
4619 }
4620 hide() {
4621 if (!this._isShown) {
4622 return;
4623 }
4624 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3);
4625 if (hideEvent.defaultPrevented) {
4626 return;
4627 }
4628 this._focustrap.deactivate();
4629 this._element.blur();
4630 this._isShown = false;
4631 this._element.classList.add(CLASS_NAME_HIDING);
4632 this._backdrop.hide();
4633 const completeCallback = () => {
4634 this._element.classList.remove(CLASS_NAME_SHOW$3, CLASS_NAME_HIDING);
4635 this._element.removeAttribute('aria-modal');
4636 this._element.removeAttribute('role');
4637 if (!this._config.scroll) {
4638 new ScrollBarHelper().reset();
4639 }
4640 EventHandler.trigger(this._element, EVENT_HIDDEN$3);
4641 };
4642 this._queueCallback(completeCallback, this._element, true);
4643 }
4644 dispose() {
4645 this._backdrop.dispose();
4646 this._focustrap.deactivate();
4647 super.dispose();
4648 }
4649
4650 // Private
4651 _initializeBackDrop() {
4652 const clickCallback = () => {
4653 if (this._config.backdrop === 'static') {
4654 EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
4655 return;
4656 }
4657 this.hide();
4658 };
4659
4660 // 'static' option will be translated to true, and booleans will keep their value
4661 const isVisible = Boolean(this._config.backdrop);
4662 return new Backdrop({
4663 className: CLASS_NAME_BACKDROP,
4664 isVisible,
4665 isAnimated: true,
4666 rootElement: this._element.parentNode,
4667 clickCallback: isVisible ? clickCallback : null
4668 });
4669 }
4670 _initializeFocusTrap() {
4671 return new FocusTrap({
4672 trapElement: this._element
4673 });
4674 }
4675 _addEventListeners() {
4676 EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {
4677 if (event.key !== ESCAPE_KEY) {
4678 return;
4679 }
4680 if (this._config.keyboard) {
4681 this.hide();
4682 return;
4683 }
4684 EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
4685 });
4686 }
4687
4688 // Static
4689 static jQueryInterface(config) {
4690 return this.each(function () {
4691 const data = Offcanvas.getOrCreateInstance(this, config);
4692 if (typeof config !== 'string') {
4693 return;
4694 }
4695 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
4696 throw new TypeError(`No method named "${config}"`);
4697 }
4698 data[config](this);
4699 });
4700 }
4701 }
4702
4703 /**
4704 * Data API implementation
4705 */
4706
4707 EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) {
4708 const target = SelectorEngine.getElementFromSelector(this);
4709 if (['A', 'AREA'].includes(this.tagName)) {
4710 event.preventDefault();
4711 }
4712 if (isDisabled(this)) {
4713 return;
4714 }
4715 EventHandler.one(target, EVENT_HIDDEN$3, () => {
4716 // focus on trigger when it is closed
4717 if (isVisible(this)) {
4718 this.focus();
4719 }
4720 });
4721
4722 // avoid conflict when clicking a toggler of an offcanvas, while another is open
4723 const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);
4724 if (alreadyOpen && alreadyOpen !== target) {
4725 Offcanvas.getInstance(alreadyOpen).hide();
4726 }
4727 const data = Offcanvas.getOrCreateInstance(target);
4728 data.toggle(this);
4729 });
4730 EventHandler.on(window, EVENT_LOAD_DATA_API$2, () => {
4731 for (const selector of SelectorEngine.find(OPEN_SELECTOR)) {
4732 Offcanvas.getOrCreateInstance(selector).show();
4733 }
4734 });
4735 EventHandler.on(window, EVENT_RESIZE, () => {
4736 for (const element of SelectorEngine.find('[aria-modal][class*=show][class*=offcanvas-]')) {
4737 if (getComputedStyle(element).position !== 'fixed') {
4738 Offcanvas.getOrCreateInstance(element).hide();
4739 }
4740 }
4741 });
4742 enableDismissTrigger(Offcanvas);
4743
4744 /**
4745 * jQuery
4746 */
4747
4748 defineJQueryPlugin(Offcanvas);
4749
4750 /**
4751 * --------------------------------------------------------------------------
4752 * Bootstrap util/sanitizer.js
4753 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
4754 * --------------------------------------------------------------------------
4755 */
4756
4757 // js-docs-start allow-list
4758 const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
4759 const DefaultAllowlist = {
4760 // Global attributes allowed on any supplied element below.
4761 '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
4762 a: ['target', 'href', 'title', 'rel'],
4763 area: [],
4764 b: [],
4765 br: [],
4766 col: [],
4767 code: [],
4768 dd: [],
4769 div: [],
4770 dl: [],
4771 dt: [],
4772 em: [],
4773 hr: [],
4774 h1: [],
4775 h2: [],
4776 h3: [],
4777 h4: [],
4778 h5: [],
4779 h6: [],
4780 i: [],
4781 img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],
4782 li: [],
4783 ol: [],
4784 p: [],
4785 pre: [],
4786 s: [],
4787 small: [],
4788 span: [],
4789 sub: [],
4790 sup: [],
4791 strong: [],
4792 u: [],
4793 ul: []
4794 };
4795 // js-docs-end allow-list
4796
4797 const uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']);
4798
4799 /**
4800 * A pattern that recognizes URLs that are safe wrt. XSS in URL navigation
4801 * contexts.
4802 *
4803 * Shout-out to Angular https://github.com/angular/angular/blob/15.2.8/packages/core/src/sanitization/url_sanitizer.ts#L38
4804 */
4805 // eslint-disable-next-line unicorn/better-regex
4806 const SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/i;
4807 const allowedAttribute = (attribute, allowedAttributeList) => {
4808 const attributeName = attribute.nodeName.toLowerCase();
4809 if (allowedAttributeList.includes(attributeName)) {
4810 if (uriAttributes.has(attributeName)) {
4811 return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue));
4812 }
4813 return true;
4814 }
4815
4816 // Check if a regular expression validates the attribute.
4817 return allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp).some(regex => regex.test(attributeName));
4818 };
4819 function sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) {
4820 if (!unsafeHtml.length) {
4821 return unsafeHtml;
4822 }
4823 if (sanitizeFunction && typeof sanitizeFunction === 'function') {
4824 return sanitizeFunction(unsafeHtml);
4825 }
4826 const domParser = new window.DOMParser();
4827 const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');
4828 const elements = [].concat(...createdDocument.body.querySelectorAll('*'));
4829 for (const element of elements) {
4830 const elementName = element.nodeName.toLowerCase();
4831 if (!Object.keys(allowList).includes(elementName)) {
4832 element.remove();
4833 continue;
4834 }
4835 const attributeList = [].concat(...element.attributes);
4836 const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []);
4837 for (const attribute of attributeList) {
4838 if (!allowedAttribute(attribute, allowedAttributes)) {
4839 element.removeAttribute(attribute.nodeName);
4840 }
4841 }
4842 }
4843 return createdDocument.body.innerHTML;
4844 }
4845
4846 /**
4847 * --------------------------------------------------------------------------
4848 * Bootstrap util/template-factory.js
4849 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
4850 * --------------------------------------------------------------------------
4851 */
4852
4853
4854 /**
4855 * Constants
4856 */
4857
4858 const NAME$5 = 'TemplateFactory';
4859 const Default$4 = {
4860 allowList: DefaultAllowlist,
4861 content: {},
4862 // { selector : text , selector2 : text2 , }
4863 extraClass: '',
4864 html: false,
4865 sanitize: true,
4866 sanitizeFn: null,
4867 template: '<div></div>'
4868 };
4869 const DefaultType$4 = {
4870 allowList: 'object',
4871 content: 'object',
4872 extraClass: '(string|function)',
4873 html: 'boolean',
4874 sanitize: 'boolean',
4875 sanitizeFn: '(null|function)',
4876 template: 'string'
4877 };
4878 const DefaultContentType = {
4879 entry: '(string|element|function|null)',
4880 selector: '(string|element)'
4881 };
4882
4883 /**
4884 * Class definition
4885 */
4886
4887 class TemplateFactory extends Config {
4888 constructor(config) {
4889 super();
4890 this._config = this._getConfig(config);
4891 }
4892
4893 // Getters
4894 static get Default() {
4895 return Default$4;
4896 }
4897 static get DefaultType() {
4898 return DefaultType$4;
4899 }
4900 static get NAME() {
4901 return NAME$5;
4902 }
4903
4904 // Public
4905 getContent() {
4906 return Object.values(this._config.content).map(config => this._resolvePossibleFunction(config)).filter(Boolean);
4907 }
4908 hasContent() {
4909 return this.getContent().length > 0;
4910 }
4911 changeContent(content) {
4912 this._checkContent(content);
4913 this._config.content = {
4914 ...this._config.content,
4915 ...content
4916 };
4917 return this;
4918 }
4919 toHtml() {
4920 const templateWrapper = document.createElement('div');
4921 templateWrapper.innerHTML = this._maybeSanitize(this._config.template);
4922 for (const [selector, text] of Object.entries(this._config.content)) {
4923 this._setContent(templateWrapper, text, selector);
4924 }
4925 const template = templateWrapper.children[0];
4926 const extraClass = this._resolvePossibleFunction(this._config.extraClass);
4927 if (extraClass) {
4928 template.classList.add(...extraClass.split(' '));
4929 }
4930 return template;
4931 }
4932
4933 // Private
4934 _typeCheckConfig(config) {
4935 super._typeCheckConfig(config);
4936 this._checkContent(config.content);
4937 }
4938 _checkContent(arg) {
4939 for (const [selector, content] of Object.entries(arg)) {
4940 super._typeCheckConfig({
4941 selector,
4942 entry: content
4943 }, DefaultContentType);
4944 }
4945 }
4946 _setContent(template, content, selector) {
4947 const templateElement = SelectorEngine.findOne(selector, template);
4948 if (!templateElement) {
4949 return;
4950 }
4951 content = this._resolvePossibleFunction(content);
4952 if (!content) {
4953 templateElement.remove();
4954 return;
4955 }
4956 if (isElement$1(content)) {
4957 this._putElementInTemplate(getElement(content), templateElement);
4958 return;
4959 }
4960 if (this._config.html) {
4961 templateElement.innerHTML = this._maybeSanitize(content);
4962 return;
4963 }
4964 templateElement.textContent = content;
4965 }
4966 _maybeSanitize(arg) {
4967 return this._config.sanitize ? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn) : arg;
4968 }
4969 _resolvePossibleFunction(arg) {
4970 return execute(arg, [this]);
4971 }
4972 _putElementInTemplate(element, templateElement) {
4973 if (this._config.html) {
4974 templateElement.innerHTML = '';
4975 templateElement.append(element);
4976 return;
4977 }
4978 templateElement.textContent = element.textContent;
4979 }
4980 }
4981
4982 /**
4983 * --------------------------------------------------------------------------
4984 * Bootstrap tooltip.js
4985 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
4986 * --------------------------------------------------------------------------
4987 */
4988
4989
4990 /**
4991 * Constants
4992 */
4993
4994 const NAME$4 = 'tooltip';
4995 const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']);
4996 const CLASS_NAME_FADE$2 = 'fade';
4997 const CLASS_NAME_MODAL = 'modal';
4998 const CLASS_NAME_SHOW$2 = 'show';
4999 const SELECTOR_TOOLTIP_INNER = '.tooltip-inner';
5000 const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`;
5001 const EVENT_MODAL_HIDE = 'hide.bs.modal';
5002 const TRIGGER_HOVER = 'hover';
5003 const TRIGGER_FOCUS = 'focus';
5004 const TRIGGER_CLICK = 'click';
5005 const TRIGGER_MANUAL = 'manual';
5006 const EVENT_HIDE$2 = 'hide';
5007 const EVENT_HIDDEN$2 = 'hidden';
5008 const EVENT_SHOW$2 = 'show';
5009 const EVENT_SHOWN$2 = 'shown';
5010 const EVENT_INSERTED = 'inserted';
5011 const EVENT_CLICK$1 = 'click';
5012 const EVENT_FOCUSIN$1 = 'focusin';
5013 const EVENT_FOCUSOUT$1 = 'focusout';
5014 const EVENT_MOUSEENTER = 'mouseenter';
5015 const EVENT_MOUSELEAVE = 'mouseleave';
5016 const AttachmentMap = {
5017 AUTO: 'auto',
5018 TOP: 'top',
5019 RIGHT: isRTL() ? 'left' : 'right',
5020 BOTTOM: 'bottom',
5021 LEFT: isRTL() ? 'right' : 'left'
5022 };
5023 const Default$3 = {
5024 allowList: DefaultAllowlist,
5025 animation: true,
5026 boundary: 'clippingParents',
5027 container: false,
5028 customClass: '',
5029 delay: 0,
5030 fallbackPlacements: ['top', 'right', 'bottom', 'left'],
5031 html: false,
5032 offset: [0, 6],
5033 placement: 'top',
5034 popperConfig: null,
5035 sanitize: true,
5036 sanitizeFn: null,
5037 selector: false,
5038 template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>',
5039 title: '',
5040 trigger: 'hover focus'
5041 };
5042 const DefaultType$3 = {
5043 allowList: 'object',
5044 animation: 'boolean',
5045 boundary: '(string|element)',
5046 container: '(string|element|boolean)',
5047 customClass: '(string|function)',
5048 delay: '(number|object)',
5049 fallbackPlacements: 'array',
5050 html: 'boolean',
5051 offset: '(array|string|function)',
5052 placement: '(string|function)',
5053 popperConfig: '(null|object|function)',
5054 sanitize: 'boolean',
5055 sanitizeFn: '(null|function)',
5056 selector: '(string|boolean)',
5057 template: 'string',
5058 title: '(string|element|function)',
5059 trigger: 'string'
5060 };
5061
5062 /**
5063 * Class definition
5064 */
5065
5066 class Tooltip extends BaseComponent {
5067 constructor(element, config) {
5068 if (typeof Popper === 'undefined') {
5069 throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)');
5070 }
5071 super(element, config);
5072
5073 // Private
5074 this._isEnabled = true;
5075 this._timeout = 0;
5076 this._isHovered = null;
5077 this._activeTrigger = {};
5078 this._popper = null;
5079 this._templateFactory = null;
5080 this._newContent = null;
5081
5082 // Protected
5083 this.tip = null;
5084 this._setListeners();
5085 if (!this._config.selector) {
5086 this._fixTitle();
5087 }
5088 }
5089
5090 // Getters
5091 static get Default() {
5092 return Default$3;
5093 }
5094 static get DefaultType() {
5095 return DefaultType$3;
5096 }
5097 static get NAME() {
5098 return NAME$4;
5099 }
5100
5101 // Public
5102 enable() {
5103 this._isEnabled = true;
5104 }
5105 disable() {
5106 this._isEnabled = false;
5107 }
5108 toggleEnabled() {
5109 this._isEnabled = !this._isEnabled;
5110 }
5111 toggle() {
5112 if (!this._isEnabled) {
5113 return;
5114 }
5115 this._activeTrigger.click = !this._activeTrigger.click;
5116 if (this._isShown()) {
5117 this._leave();
5118 return;
5119 }
5120 this._enter();
5121 }
5122 dispose() {
5123 clearTimeout(this._timeout);
5124 EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
5125 if (this._element.getAttribute('data-bs-original-title')) {
5126 this._element.setAttribute('title', this._element.getAttribute('data-bs-original-title'));
5127 }
5128 this._disposePopper();
5129 super.dispose();
5130 }
5131 show() {
5132 if (this._element.style.display === 'none') {
5133 throw new Error('Please use show on visible elements');
5134 }
5135 if (!(this._isWithContent() && this._isEnabled)) {
5136 return;
5137 }
5138 const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW$2));
5139 const shadowRoot = findShadowRoot(this._element);
5140 const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element);
5141 if (showEvent.defaultPrevented || !isInTheDom) {
5142 return;
5143 }
5144
5145 // TODO: v6 remove this or make it optional
5146 this._disposePopper();
5147 const tip = this._getTipElement();
5148 this._element.setAttribute('aria-describedby', tip.getAttribute('id'));
5149 const {
5150 container
5151 } = this._config;
5152 if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
5153 container.append(tip);
5154 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED));
5155 }
5156 this._popper = this._createPopper(tip);
5157 tip.classList.add(CLASS_NAME_SHOW$2);
5158
5159 // If this is a touch-enabled device we add extra
5160 // empty mouseover listeners to the body's immediate children;
5161 // only needed because of broken event delegation on iOS
5162 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
5163 if ('ontouchstart' in document.documentElement) {
5164 for (const element of [].concat(...document.body.children)) {
5165 EventHandler.on(element, 'mouseover', noop);
5166 }
5167 }
5168 const complete = () => {
5169 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOWN$2));
5170 if (this._isHovered === false) {
5171 this._leave();
5172 }
5173 this._isHovered = false;
5174 };
5175 this._queueCallback(complete, this.tip, this._isAnimated());
5176 }
5177 hide() {
5178 if (!this._isShown()) {
5179 return;
5180 }
5181 const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE$2));
5182 if (hideEvent.defaultPrevented) {
5183 return;
5184 }
5185 const tip = this._getTipElement();
5186 tip.classList.remove(CLASS_NAME_SHOW$2);
5187
5188 // If this is a touch-enabled device we remove the extra
5189 // empty mouseover listeners we added for iOS support
5190 if ('ontouchstart' in document.documentElement) {
5191 for (const element of [].concat(...document.body.children)) {
5192 EventHandler.off(element, 'mouseover', noop);
5193 }
5194 }
5195 this._activeTrigger[TRIGGER_CLICK] = false;
5196 this._activeTrigger[TRIGGER_FOCUS] = false;
5197 this._activeTrigger[TRIGGER_HOVER] = false;
5198 this._isHovered = null; // it is a trick to support manual triggering
5199
5200 const complete = () => {
5201 if (this._isWithActiveTrigger()) {
5202 return;
5203 }
5204 if (!this._isHovered) {
5205 this._disposePopper();
5206 }
5207 this._element.removeAttribute('aria-describedby');
5208 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDDEN$2));
5209 };
5210 this._queueCallback(complete, this.tip, this._isAnimated());
5211 }
5212 update() {
5213 if (this._popper) {
5214 this._popper.update();
5215 }
5216 }
5217
5218 // Protected
5219 _isWithContent() {
5220 return Boolean(this._getTitle());
5221 }
5222 _getTipElement() {
5223 if (!this.tip) {
5224 this.tip = this._createTipElement(this._newContent || this._getContentForTemplate());
5225 }
5226 return this.tip;
5227 }
5228 _createTipElement(content) {
5229 const tip = this._getTemplateFactory(content).toHtml();
5230
5231 // TODO: remove this check in v6
5232 if (!tip) {
5233 return null;
5234 }
5235 tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2);
5236 // TODO: v6 the following can be achieved with CSS only
5237 tip.classList.add(`bs-${this.constructor.NAME}-auto`);
5238 const tipId = getUID(this.constructor.NAME).toString();
5239 tip.setAttribute('id', tipId);
5240 if (this._isAnimated()) {
5241 tip.classList.add(CLASS_NAME_FADE$2);
5242 }
5243 return tip;
5244 }
5245 setContent(content) {
5246 this._newContent = content;
5247 if (this._isShown()) {
5248 this._disposePopper();
5249 this.show();
5250 }
5251 }
5252 _getTemplateFactory(content) {
5253 if (this._templateFactory) {
5254 this._templateFactory.changeContent(content);
5255 } else {
5256 this._templateFactory = new TemplateFactory({
5257 ...this._config,
5258 // the `content` var has to be after `this._config`
5259 // to override config.content in case of popover
5260 content,
5261 extraClass: this._resolvePossibleFunction(this._config.customClass)
5262 });
5263 }
5264 return this._templateFactory;
5265 }
5266 _getContentForTemplate() {
5267 return {
5268 [SELECTOR_TOOLTIP_INNER]: this._getTitle()
5269 };
5270 }
5271 _getTitle() {
5272 return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute('data-bs-original-title');
5273 }
5274
5275 // Private
5276 _initializeOnDelegatedTarget(event) {
5277 return this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig());
5278 }
5279 _isAnimated() {
5280 return this._config.animation || this.tip && this.tip.classList.contains(CLASS_NAME_FADE$2);
5281 }
5282 _isShown() {
5283 return this.tip && this.tip.classList.contains(CLASS_NAME_SHOW$2);
5284 }
5285 _createPopper(tip) {
5286 const placement = execute(this._config.placement, [this, tip, this._element]);
5287 const attachment = AttachmentMap[placement.toUpperCase()];
5288 return createPopper(this._element, tip, this._getPopperConfig(attachment));
5289 }
5290 _getOffset() {
5291 const {
5292 offset
5293 } = this._config;
5294 if (typeof offset === 'string') {
5295 return offset.split(',').map(value => Number.parseInt(value, 10));
5296 }
5297 if (typeof offset === 'function') {
5298 return popperData => offset(popperData, this._element);
5299 }
5300 return offset;
5301 }
5302 _resolvePossibleFunction(arg) {
5303 return execute(arg, [this._element]);
5304 }
5305 _getPopperConfig(attachment) {
5306 const defaultBsPopperConfig = {
5307 placement: attachment,
5308 modifiers: [{
5309 name: 'flip',
5310 options: {
5311 fallbackPlacements: this._config.fallbackPlacements
5312 }
5313 }, {
5314 name: 'offset',
5315 options: {
5316 offset: this._getOffset()
5317 }
5318 }, {
5319 name: 'preventOverflow',
5320 options: {
5321 boundary: this._config.boundary
5322 }
5323 }, {
5324 name: 'arrow',
5325 options: {
5326 element: `.${this.constructor.NAME}-arrow`
5327 }
5328 }, {
5329 name: 'preSetPlacement',
5330 enabled: true,
5331 phase: 'beforeMain',
5332 fn: data => {
5333 // Pre-set Popper's placement attribute in order to read the arrow sizes properly.
5334 // Otherwise, Popper mixes up the width and height dimensions since the initial arrow style is for top placement
5335 this._getTipElement().setAttribute('data-popper-placement', data.state.placement);
5336 }
5337 }]
5338 };
5339 return {
5340 ...defaultBsPopperConfig,
5341 ...execute(this._config.popperConfig, [defaultBsPopperConfig])
5342 };
5343 }
5344 _setListeners() {
5345 const triggers = this._config.trigger.split(' ');
5346 for (const trigger of triggers) {
5347 if (trigger === 'click') {
5348 EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK$1), this._config.selector, event => {
5349 const context = this._initializeOnDelegatedTarget(event);
5350 context.toggle();
5351 });
5352 } else if (trigger !== TRIGGER_MANUAL) {
5353 const eventIn = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSEENTER) : this.constructor.eventName(EVENT_FOCUSIN$1);
5354 const eventOut = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSELEAVE) : this.constructor.eventName(EVENT_FOCUSOUT$1);
5355 EventHandler.on(this._element, eventIn, this._config.selector, event => {
5356 const context = this._initializeOnDelegatedTarget(event);
5357 context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;
5358 context._enter();
5359 });
5360 EventHandler.on(this._element, eventOut, this._config.selector, event => {
5361 const context = this._initializeOnDelegatedTarget(event);
5362 context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget);
5363 context._leave();
5364 });
5365 }
5366 }
5367 this._hideModalHandler = () => {
5368 if (this._element) {
5369 this.hide();
5370 }
5371 };
5372 EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
5373 }
5374 _fixTitle() {
5375 const title = this._element.getAttribute('title');
5376 if (!title) {
5377 return;
5378 }
5379 if (!this._element.getAttribute('aria-label') && !this._element.textContent.trim()) {
5380 this._element.setAttribute('aria-label', title);
5381 }
5382 this._element.setAttribute('data-bs-original-title', title); // DO NOT USE IT. Is only for backwards compatibility
5383 this._element.removeAttribute('title');
5384 }
5385 _enter() {
5386 if (this._isShown() || this._isHovered) {
5387 this._isHovered = true;
5388 return;
5389 }
5390 this._isHovered = true;
5391 this._setTimeout(() => {
5392 if (this._isHovered) {
5393 this.show();
5394 }
5395 }, this._config.delay.show);
5396 }
5397 _leave() {
5398 if (this._isWithActiveTrigger()) {
5399 return;
5400 }
5401 this._isHovered = false;
5402 this._setTimeout(() => {
5403 if (!this._isHovered) {
5404 this.hide();
5405 }
5406 }, this._config.delay.hide);
5407 }
5408 _setTimeout(handler, timeout) {
5409 clearTimeout(this._timeout);
5410 this._timeout = setTimeout(handler, timeout);
5411 }
5412 _isWithActiveTrigger() {
5413 return Object.values(this._activeTrigger).includes(true);
5414 }
5415 _getConfig(config) {
5416 const dataAttributes = Manipulator.getDataAttributes(this._element);
5417 for (const dataAttribute of Object.keys(dataAttributes)) {
5418 if (DISALLOWED_ATTRIBUTES.has(dataAttribute)) {
5419 delete dataAttributes[dataAttribute];
5420 }
5421 }
5422 config = {
5423 ...dataAttributes,
5424 ...(typeof config === 'object' && config ? config : {})
5425 };
5426 config = this._mergeConfigObj(config);
5427 config = this._configAfterMerge(config);
5428 this._typeCheckConfig(config);
5429 return config;
5430 }
5431 _configAfterMerge(config) {
5432 config.container = config.container === false ? document.body : getElement(config.container);
5433 if (typeof config.delay === 'number') {
5434 config.delay = {
5435 show: config.delay,
5436 hide: config.delay
5437 };
5438 }
5439 if (typeof config.title === 'number') {
5440 config.title = config.title.toString();
5441 }
5442 if (typeof config.content === 'number') {
5443 config.content = config.content.toString();
5444 }
5445 return config;
5446 }
5447 _getDelegateConfig() {
5448 const config = {};
5449 for (const [key, value] of Object.entries(this._config)) {
5450 if (this.constructor.Default[key] !== value) {
5451 config[key] = value;
5452 }
5453 }
5454 config.selector = false;
5455 config.trigger = 'manual';
5456
5457 // In the future can be replaced with:
5458 // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])
5459 // `Object.fromEntries(keysWithDifferentValues)`
5460 return config;
5461 }
5462 _disposePopper() {
5463 if (this._popper) {
5464 this._popper.destroy();
5465 this._popper = null;
5466 }
5467 if (this.tip) {
5468 this.tip.remove();
5469 this.tip = null;
5470 }
5471 }
5472
5473 // Static
5474 static jQueryInterface(config) {
5475 return this.each(function () {
5476 const data = Tooltip.getOrCreateInstance(this, config);
5477 if (typeof config !== 'string') {
5478 return;
5479 }
5480 if (typeof data[config] === 'undefined') {
5481 throw new TypeError(`No method named "${config}"`);
5482 }
5483 data[config]();
5484 });
5485 }
5486 }
5487
5488 /**
5489 * jQuery
5490 */
5491
5492 defineJQueryPlugin(Tooltip);
5493
5494 /**
5495 * --------------------------------------------------------------------------
5496 * Bootstrap popover.js
5497 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
5498 * --------------------------------------------------------------------------
5499 */
5500
5501
5502 /**
5503 * Constants
5504 */
5505
5506 const NAME$3 = 'popover';
5507 const SELECTOR_TITLE = '.popover-header';
5508 const SELECTOR_CONTENT = '.popover-body';
5509 const Default$2 = {
5510 ...Tooltip.Default,
5511 content: '',
5512 offset: [0, 8],
5513 placement: 'right',
5514 template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>',
5515 trigger: 'click'
5516 };
5517 const DefaultType$2 = {
5518 ...Tooltip.DefaultType,
5519 content: '(null|string|element|function)'
5520 };
5521
5522 /**
5523 * Class definition
5524 */
5525
5526 class Popover extends Tooltip {
5527 // Getters
5528 static get Default() {
5529 return Default$2;
5530 }
5531 static get DefaultType() {
5532 return DefaultType$2;
5533 }
5534 static get NAME() {
5535 return NAME$3;
5536 }
5537
5538 // Overrides
5539 _isWithContent() {
5540 return this._getTitle() || this._getContent();
5541 }
5542
5543 // Private
5544 _getContentForTemplate() {
5545 return {
5546 [SELECTOR_TITLE]: this._getTitle(),
5547 [SELECTOR_CONTENT]: this._getContent()
5548 };
5549 }
5550 _getContent() {
5551 return this._resolvePossibleFunction(this._config.content);
5552 }
5553
5554 // Static
5555 static jQueryInterface(config) {
5556 return this.each(function () {
5557 const data = Popover.getOrCreateInstance(this, config);
5558 if (typeof config !== 'string') {
5559 return;
5560 }
5561 if (typeof data[config] === 'undefined') {
5562 throw new TypeError(`No method named "${config}"`);
5563 }
5564 data[config]();
5565 });
5566 }
5567 }
5568
5569 /**
5570 * jQuery
5571 */
5572
5573 defineJQueryPlugin(Popover);
5574
5575 /**
5576 * --------------------------------------------------------------------------
5577 * Bootstrap scrollspy.js
5578 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
5579 * --------------------------------------------------------------------------
5580 */
5581
5582
5583 /**
5584 * Constants
5585 */
5586
5587 const NAME$2 = 'scrollspy';
5588 const DATA_KEY$2 = 'bs.scrollspy';
5589 const EVENT_KEY$2 = `.${DATA_KEY$2}`;
5590 const DATA_API_KEY = '.data-api';
5591 const EVENT_ACTIVATE = `activate${EVENT_KEY$2}`;
5592 const EVENT_CLICK = `click${EVENT_KEY$2}`;
5593 const EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$2}${DATA_API_KEY}`;
5594 const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';
5595 const CLASS_NAME_ACTIVE$1 = 'active';
5596 const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]';
5597 const SELECTOR_TARGET_LINKS = '[href]';
5598 const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
5599 const SELECTOR_NAV_LINKS = '.nav-link';
5600 const SELECTOR_NAV_ITEMS = '.nav-item';
5601 const SELECTOR_LIST_ITEMS = '.list-group-item';
5602 const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`;
5603 const SELECTOR_DROPDOWN = '.dropdown';
5604 const SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle';
5605 const Default$1 = {
5606 offset: null,
5607 // TODO: v6 @deprecated, keep it for backwards compatibility reasons
5608 rootMargin: '0px 0px -25%',
5609 smoothScroll: false,
5610 target: null,
5611 threshold: [0.1, 0.5, 1]
5612 };
5613 const DefaultType$1 = {
5614 offset: '(number|null)',
5615 // TODO v6 @deprecated, keep it for backwards compatibility reasons
5616 rootMargin: 'string',
5617 smoothScroll: 'boolean',
5618 target: 'element',
5619 threshold: 'array'
5620 };
5621
5622 /**
5623 * Class definition
5624 */
5625
5626 class ScrollSpy extends BaseComponent {
5627 constructor(element, config) {
5628 super(element, config);
5629
5630 // this._element is the observablesContainer and config.target the menu links wrapper
5631 this._targetLinks = new Map();
5632 this._observableSections = new Map();
5633 this._rootElement = getComputedStyle(this._element).overflowY === 'visible' ? null : this._element;
5634 this._activeTarget = null;
5635 this._observer = null;
5636 this._previousScrollData = {
5637 visibleEntryTop: 0,
5638 parentScrollTop: 0
5639 };
5640 this.refresh(); // initialize
5641 }
5642
5643 // Getters
5644 static get Default() {
5645 return Default$1;
5646 }
5647 static get DefaultType() {
5648 return DefaultType$1;
5649 }
5650 static get NAME() {
5651 return NAME$2;
5652 }
5653
5654 // Public
5655 refresh() {
5656 this._initializeTargetsAndObservables();
5657 this._maybeEnableSmoothScroll();
5658 if (this._observer) {
5659 this._observer.disconnect();
5660 } else {
5661 this._observer = this._getNewObserver();
5662 }
5663 for (const section of this._observableSections.values()) {
5664 this._observer.observe(section);
5665 }
5666 }
5667 dispose() {
5668 this._observer.disconnect();
5669 super.dispose();
5670 }
5671
5672 // Private
5673 _configAfterMerge(config) {
5674 // TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case
5675 config.target = getElement(config.target) || document.body;
5676
5677 // TODO: v6 Only for backwards compatibility reasons. Use rootMargin only
5678 config.rootMargin = config.offset ? `${config.offset}px 0px -30%` : config.rootMargin;
5679 if (typeof config.threshold === 'string') {
5680 config.threshold = config.threshold.split(',').map(value => Number.parseFloat(value));
5681 }
5682 return config;
5683 }
5684 _maybeEnableSmoothScroll() {
5685 if (!this._config.smoothScroll) {
5686 return;
5687 }
5688
5689 // unregister any previous listeners
5690 EventHandler.off(this._config.target, EVENT_CLICK);
5691 EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, event => {
5692 const observableSection = this._observableSections.get(event.target.hash);
5693 if (observableSection) {
5694 event.preventDefault();
5695 const root = this._rootElement || window;
5696 const height = observableSection.offsetTop - this._element.offsetTop;
5697 if (root.scrollTo) {
5698 root.scrollTo({
5699 top: height,
5700 behavior: 'smooth'
5701 });
5702 return;
5703 }
5704
5705 // Chrome 60 doesn't support `scrollTo`
5706 root.scrollTop = height;
5707 }
5708 });
5709 }
5710 _getNewObserver() {
5711 const options = {
5712 root: this._rootElement,
5713 threshold: this._config.threshold,
5714 rootMargin: this._config.rootMargin
5715 };
5716 return new IntersectionObserver(entries => this._observerCallback(entries), options);
5717 }
5718
5719 // The logic of selection
5720 _observerCallback(entries) {
5721 const targetElement = entry => this._targetLinks.get(`#${entry.target.id}`);
5722 const activate = entry => {
5723 this._previousScrollData.visibleEntryTop = entry.target.offsetTop;
5724 this._process(targetElement(entry));
5725 };
5726 const parentScrollTop = (this._rootElement || document.documentElement).scrollTop;
5727 const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop;
5728 this._previousScrollData.parentScrollTop = parentScrollTop;
5729 for (const entry of entries) {
5730 if (!entry.isIntersecting) {
5731 this._activeTarget = null;
5732 this._clearActiveClass(targetElement(entry));
5733 continue;
5734 }
5735 const entryIsLowerThanPrevious = entry.target.offsetTop >= this._previousScrollData.visibleEntryTop;
5736 // if we are scrolling down, pick the bigger offsetTop
5737 if (userScrollsDown && entryIsLowerThanPrevious) {
5738 activate(entry);
5739 // if parent isn't scrolled, let's keep the first visible item, breaking the iteration
5740 if (!parentScrollTop) {
5741 return;
5742 }
5743 continue;
5744 }
5745
5746 // if we are scrolling up, pick the smallest offsetTop
5747 if (!userScrollsDown && !entryIsLowerThanPrevious) {
5748 activate(entry);
5749 }
5750 }
5751 }
5752 _initializeTargetsAndObservables() {
5753 this._targetLinks = new Map();
5754 this._observableSections = new Map();
5755 const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target);
5756 for (const anchor of targetLinks) {
5757 // ensure that the anchor has an id and is not disabled
5758 if (!anchor.hash || isDisabled(anchor)) {
5759 continue;
5760 }
5761 const observableSection = SelectorEngine.findOne(decodeURI(anchor.hash), this._element);
5762
5763 // ensure that the observableSection exists & is visible
5764 if (isVisible(observableSection)) {
5765 this._targetLinks.set(decodeURI(anchor.hash), anchor);
5766 this._observableSections.set(anchor.hash, observableSection);
5767 }
5768 }
5769 }
5770 _process(target) {
5771 if (this._activeTarget === target) {
5772 return;
5773 }
5774 this._clearActiveClass(this._config.target);
5775 this._activeTarget = target;
5776 target.classList.add(CLASS_NAME_ACTIVE$1);
5777 this._activateParents(target);
5778 EventHandler.trigger(this._element, EVENT_ACTIVATE, {
5779 relatedTarget: target
5780 });
5781 }
5782 _activateParents(target) {
5783 // Activate dropdown parents
5784 if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
5785 SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, target.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$1);
5786 return;
5787 }
5788 for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) {
5789 // Set triggered links parents as active
5790 // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
5791 for (const item of SelectorEngine.prev(listGroup, SELECTOR_LINK_ITEMS)) {
5792 item.classList.add(CLASS_NAME_ACTIVE$1);
5793 }
5794 }
5795 }
5796 _clearActiveClass(parent) {
5797 parent.classList.remove(CLASS_NAME_ACTIVE$1);
5798 const activeNodes = SelectorEngine.find(`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE$1}`, parent);
5799 for (const node of activeNodes) {
5800 node.classList.remove(CLASS_NAME_ACTIVE$1);
5801 }
5802 }
5803
5804 // Static
5805 static jQueryInterface(config) {
5806 return this.each(function () {
5807 const data = ScrollSpy.getOrCreateInstance(this, config);
5808 if (typeof config !== 'string') {
5809 return;
5810 }
5811 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
5812 throw new TypeError(`No method named "${config}"`);
5813 }
5814 data[config]();
5815 });
5816 }
5817 }
5818
5819 /**
5820 * Data API implementation
5821 */
5822
5823 EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => {
5824 for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) {
5825 ScrollSpy.getOrCreateInstance(spy);
5826 }
5827 });
5828
5829 /**
5830 * jQuery
5831 */
5832
5833 defineJQueryPlugin(ScrollSpy);
5834
5835 /**
5836 * --------------------------------------------------------------------------
5837 * Bootstrap tab.js
5838 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
5839 * --------------------------------------------------------------------------
5840 */
5841
5842
5843 /**
5844 * Constants
5845 */
5846
5847 const NAME$1 = 'tab';
5848 const DATA_KEY$1 = 'bs.tab';
5849 const EVENT_KEY$1 = `.${DATA_KEY$1}`;
5850 const EVENT_HIDE$1 = `hide${EVENT_KEY$1}`;
5851 const EVENT_HIDDEN$1 = `hidden${EVENT_KEY$1}`;
5852 const EVENT_SHOW$1 = `show${EVENT_KEY$1}`;
5853 const EVENT_SHOWN$1 = `shown${EVENT_KEY$1}`;
5854 const EVENT_CLICK_DATA_API = `click${EVENT_KEY$1}`;
5855 const EVENT_KEYDOWN = `keydown${EVENT_KEY$1}`;
5856 const EVENT_LOAD_DATA_API = `load${EVENT_KEY$1}`;
5857 const ARROW_LEFT_KEY = 'ArrowLeft';
5858 const ARROW_RIGHT_KEY = 'ArrowRight';
5859 const ARROW_UP_KEY = 'ArrowUp';
5860 const ARROW_DOWN_KEY = 'ArrowDown';
5861 const HOME_KEY = 'Home';
5862 const END_KEY = 'End';
5863 const CLASS_NAME_ACTIVE = 'active';
5864 const CLASS_NAME_FADE$1 = 'fade';
5865 const CLASS_NAME_SHOW$1 = 'show';
5866 const CLASS_DROPDOWN = 'dropdown';
5867 const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
5868 const SELECTOR_DROPDOWN_MENU = '.dropdown-menu';
5869 const NOT_SELECTOR_DROPDOWN_TOGGLE = `:not(${SELECTOR_DROPDOWN_TOGGLE})`;
5870 const SELECTOR_TAB_PANEL = '.list-group, .nav, [role="tablist"]';
5871 const SELECTOR_OUTER = '.nav-item, .list-group-item';
5872 const SELECTOR_INNER = `.nav-link${NOT_SELECTOR_DROPDOWN_TOGGLE}, .list-group-item${NOT_SELECTOR_DROPDOWN_TOGGLE}, [role="tab"]${NOT_SELECTOR_DROPDOWN_TOGGLE}`;
5873 const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]'; // TODO: could only be `tab` in v6
5874 const SELECTOR_INNER_ELEM = `${SELECTOR_INNER}, ${SELECTOR_DATA_TOGGLE}`;
5875 const SELECTOR_DATA_TOGGLE_ACTIVE = `.${CLASS_NAME_ACTIVE}[data-bs-toggle="tab"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="pill"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="list"]`;
5876
5877 /**
5878 * Class definition
5879 */
5880
5881 class Tab extends BaseComponent {
5882 constructor(element) {
5883 super(element);
5884 this._parent = this._element.closest(SELECTOR_TAB_PANEL);
5885 if (!this._parent) {
5886 return;
5887 // TODO: should throw exception in v6
5888 // throw new TypeError(`${element.outerHTML} has not a valid parent ${SELECTOR_INNER_ELEM}`)
5889 }
5890
5891 // Set up initial aria attributes
5892 this._setInitialAttributes(this._parent, this._getChildren());
5893 EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event));
5894 }
5895
5896 // Getters
5897 static get NAME() {
5898 return NAME$1;
5899 }
5900
5901 // Public
5902 show() {
5903 // Shows this elem and deactivate the active sibling if exists
5904 const innerElem = this._element;
5905 if (this._elemIsActive(innerElem)) {
5906 return;
5907 }
5908
5909 // Search for active tab on same parent to deactivate it
5910 const active = this._getActiveElem();
5911 const hideEvent = active ? EventHandler.trigger(active, EVENT_HIDE$1, {
5912 relatedTarget: innerElem
5913 }) : null;
5914 const showEvent = EventHandler.trigger(innerElem, EVENT_SHOW$1, {
5915 relatedTarget: active
5916 });
5917 if (showEvent.defaultPrevented || hideEvent && hideEvent.defaultPrevented) {
5918 return;
5919 }
5920 this._deactivate(active, innerElem);
5921 this._activate(innerElem, active);
5922 }
5923
5924 // Private
5925 _activate(element, relatedElem) {
5926 if (!element) {
5927 return;
5928 }
5929 element.classList.add(CLASS_NAME_ACTIVE);
5930 this._activate(SelectorEngine.getElementFromSelector(element)); // Search and activate/show the proper section
5931
5932 const complete = () => {
5933 if (element.getAttribute('role') !== 'tab') {
5934 element.classList.add(CLASS_NAME_SHOW$1);
5935 return;
5936 }
5937 element.removeAttribute('tabindex');
5938 element.setAttribute('aria-selected', true);
5939 this._toggleDropDown(element, true);
5940 EventHandler.trigger(element, EVENT_SHOWN$1, {
5941 relatedTarget: relatedElem
5942 });
5943 };
5944 this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1));
5945 }
5946 _deactivate(element, relatedElem) {
5947 if (!element) {
5948 return;
5949 }
5950 element.classList.remove(CLASS_NAME_ACTIVE);
5951 element.blur();
5952 this._deactivate(SelectorEngine.getElementFromSelector(element)); // Search and deactivate the shown section too
5953
5954 const complete = () => {
5955 if (element.getAttribute('role') !== 'tab') {
5956 element.classList.remove(CLASS_NAME_SHOW$1);
5957 return;
5958 }
5959 element.setAttribute('aria-selected', false);
5960 element.setAttribute('tabindex', '-1');
5961 this._toggleDropDown(element, false);
5962 EventHandler.trigger(element, EVENT_HIDDEN$1, {
5963 relatedTarget: relatedElem
5964 });
5965 };
5966 this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1));
5967 }
5968 _keydown(event) {
5969 if (![ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY, HOME_KEY, END_KEY].includes(event.key)) {
5970 return;
5971 }
5972 event.stopPropagation(); // stopPropagation/preventDefault both added to support up/down keys without scrolling the page
5973 event.preventDefault();
5974 const children = this._getChildren().filter(element => !isDisabled(element));
5975 let nextActiveElement;
5976 if ([HOME_KEY, END_KEY].includes(event.key)) {
5977 nextActiveElement = children[event.key === HOME_KEY ? 0 : children.length - 1];
5978 } else {
5979 const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key);
5980 nextActiveElement = getNextActiveElement(children, event.target, isNext, true);
5981 }
5982 if (nextActiveElement) {
5983 nextActiveElement.focus({
5984 preventScroll: true
5985 });
5986 Tab.getOrCreateInstance(nextActiveElement).show();
5987 }
5988 }
5989 _getChildren() {
5990 // collection of inner elements
5991 return SelectorEngine.find(SELECTOR_INNER_ELEM, this._parent);
5992 }
5993 _getActiveElem() {
5994 return this._getChildren().find(child => this._elemIsActive(child)) || null;
5995 }
5996 _setInitialAttributes(parent, children) {
5997 this._setAttributeIfNotExists(parent, 'role', 'tablist');
5998 for (const child of children) {
5999 this._setInitialAttributesOnChild(child);
6000 }
6001 }
6002 _setInitialAttributesOnChild(child) {
6003 child = this._getInnerElement(child);
6004 const isActive = this._elemIsActive(child);
6005 const outerElem = this._getOuterElement(child);
6006 child.setAttribute('aria-selected', isActive);
6007 if (outerElem !== child) {
6008 this._setAttributeIfNotExists(outerElem, 'role', 'presentation');
6009 }
6010 if (!isActive) {
6011 child.setAttribute('tabindex', '-1');
6012 }
6013 this._setAttributeIfNotExists(child, 'role', 'tab');
6014
6015 // set attributes to the related panel too
6016 this._setInitialAttributesOnTargetPanel(child);
6017 }
6018 _setInitialAttributesOnTargetPanel(child) {
6019 const target = SelectorEngine.getElementFromSelector(child);
6020 if (!target) {
6021 return;
6022 }
6023 this._setAttributeIfNotExists(target, 'role', 'tabpanel');
6024 if (child.id) {
6025 this._setAttributeIfNotExists(target, 'aria-labelledby', `${child.id}`);
6026 }
6027 }
6028 _toggleDropDown(element, open) {
6029 const outerElem = this._getOuterElement(element);
6030 if (!outerElem.classList.contains(CLASS_DROPDOWN)) {
6031 return;
6032 }
6033 const toggle = (selector, className) => {
6034 const element = SelectorEngine.findOne(selector, outerElem);
6035 if (element) {
6036 element.classList.toggle(className, open);
6037 }
6038 };
6039 toggle(SELECTOR_DROPDOWN_TOGGLE, CLASS_NAME_ACTIVE);
6040 toggle(SELECTOR_DROPDOWN_MENU, CLASS_NAME_SHOW$1);
6041 outerElem.setAttribute('aria-expanded', open);
6042 }
6043 _setAttributeIfNotExists(element, attribute, value) {
6044 if (!element.hasAttribute(attribute)) {
6045 element.setAttribute(attribute, value);
6046 }
6047 }
6048 _elemIsActive(elem) {
6049 return elem.classList.contains(CLASS_NAME_ACTIVE);
6050 }
6051
6052 // Try to get the inner element (usually the .nav-link)
6053 _getInnerElement(elem) {
6054 return elem.matches(SELECTOR_INNER_ELEM) ? elem : SelectorEngine.findOne(SELECTOR_INNER_ELEM, elem);
6055 }
6056
6057 // Try to get the outer element (usually the .nav-item)
6058 _getOuterElement(elem) {
6059 return elem.closest(SELECTOR_OUTER) || elem;
6060 }
6061
6062 // Static
6063 static jQueryInterface(config) {
6064 return this.each(function () {
6065 const data = Tab.getOrCreateInstance(this);
6066 if (typeof config !== 'string') {
6067 return;
6068 }
6069 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
6070 throw new TypeError(`No method named "${config}"`);
6071 }
6072 data[config]();
6073 });
6074 }
6075 }
6076
6077 /**
6078 * Data API implementation
6079 */
6080
6081 EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
6082 if (['A', 'AREA'].includes(this.tagName)) {
6083 event.preventDefault();
6084 }
6085 if (isDisabled(this)) {
6086 return;
6087 }
6088 Tab.getOrCreateInstance(this).show();
6089 });
6090
6091 /**
6092 * Initialize on focus
6093 */
6094 EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
6095 for (const element of SelectorEngine.find(SELECTOR_DATA_TOGGLE_ACTIVE)) {
6096 Tab.getOrCreateInstance(element);
6097 }
6098 });
6099 /**
6100 * jQuery
6101 */
6102
6103 defineJQueryPlugin(Tab);
6104
6105 /**
6106 * --------------------------------------------------------------------------
6107 * Bootstrap toast.js
6108 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
6109 * --------------------------------------------------------------------------
6110 */
6111
6112
6113 /**
6114 * Constants
6115 */
6116
6117 const NAME = 'toast';
6118 const DATA_KEY = 'bs.toast';
6119 const EVENT_KEY = `.${DATA_KEY}`;
6120 const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`;
6121 const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`;
6122 const EVENT_FOCUSIN = `focusin${EVENT_KEY}`;
6123 const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`;
6124 const EVENT_HIDE = `hide${EVENT_KEY}`;
6125 const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
6126 const EVENT_SHOW = `show${EVENT_KEY}`;
6127 const EVENT_SHOWN = `shown${EVENT_KEY}`;
6128 const CLASS_NAME_FADE = 'fade';
6129 const CLASS_NAME_HIDE = 'hide'; // @deprecated - kept here only for backwards compatibility
6130 const CLASS_NAME_SHOW = 'show';
6131 const CLASS_NAME_SHOWING = 'showing';
6132 const DefaultType = {
6133 animation: 'boolean',
6134 autohide: 'boolean',
6135 delay: 'number'
6136 };
6137 const Default = {
6138 animation: true,
6139 autohide: true,
6140 delay: 5000
6141 };
6142
6143 /**
6144 * Class definition
6145 */
6146
6147 class Toast extends BaseComponent {
6148 constructor(element, config) {
6149 super(element, config);
6150 this._timeout = null;
6151 this._hasMouseInteraction = false;
6152 this._hasKeyboardInteraction = false;
6153 this._setListeners();
6154 }
6155
6156 // Getters
6157 static get Default() {
6158 return Default;
6159 }
6160 static get DefaultType() {
6161 return DefaultType;
6162 }
6163 static get NAME() {
6164 return NAME;
6165 }
6166
6167 // Public
6168 show() {
6169 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW);
6170 if (showEvent.defaultPrevented) {
6171 return;
6172 }
6173 this._clearTimeout();
6174 if (this._config.animation) {
6175 this._element.classList.add(CLASS_NAME_FADE);
6176 }
6177 const complete = () => {
6178 this._element.classList.remove(CLASS_NAME_SHOWING);
6179 EventHandler.trigger(this._element, EVENT_SHOWN);
6180 this._maybeScheduleHide();
6181 };
6182 this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated
6183 reflow(this._element);
6184 this._element.classList.add(CLASS_NAME_SHOW, CLASS_NAME_SHOWING);
6185 this._queueCallback(complete, this._element, this._config.animation);
6186 }
6187 hide() {
6188 if (!this.isShown()) {
6189 return;
6190 }
6191 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE);
6192 if (hideEvent.defaultPrevented) {
6193 return;
6194 }
6195 const complete = () => {
6196 this._element.classList.add(CLASS_NAME_HIDE); // @deprecated
6197 this._element.classList.remove(CLASS_NAME_SHOWING, CLASS_NAME_SHOW);
6198 EventHandler.trigger(this._element, EVENT_HIDDEN);
6199 };
6200 this._element.classList.add(CLASS_NAME_SHOWING);
6201 this._queueCallback(complete, this._element, this._config.animation);
6202 }
6203 dispose() {
6204 this._clearTimeout();
6205 if (this.isShown()) {
6206 this._element.classList.remove(CLASS_NAME_SHOW);
6207 }
6208 super.dispose();
6209 }
6210 isShown() {
6211 return this._element.classList.contains(CLASS_NAME_SHOW);
6212 }
6213
6214 // Private
6215
6216 _maybeScheduleHide() {
6217 if (!this._config.autohide) {
6218 return;
6219 }
6220 if (this._hasMouseInteraction || this._hasKeyboardInteraction) {
6221 return;
6222 }
6223 this._timeout = setTimeout(() => {
6224 this.hide();
6225 }, this._config.delay);
6226 }
6227 _onInteraction(event, isInteracting) {
6228 switch (event.type) {
6229 case 'mouseover':
6230 case 'mouseout':
6231 {
6232 this._hasMouseInteraction = isInteracting;
6233 break;
6234 }
6235 case 'focusin':
6236 case 'focusout':
6237 {
6238 this._hasKeyboardInteraction = isInteracting;
6239 break;
6240 }
6241 }
6242 if (isInteracting) {
6243 this._clearTimeout();
6244 return;
6245 }
6246 const nextElement = event.relatedTarget;
6247 if (this._element === nextElement || this._element.contains(nextElement)) {
6248 return;
6249 }
6250 this._maybeScheduleHide();
6251 }
6252 _setListeners() {
6253 EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true));
6254 EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false));
6255 EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true));
6256 EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false));
6257 }
6258 _clearTimeout() {
6259 clearTimeout(this._timeout);
6260 this._timeout = null;
6261 }
6262
6263 // Static
6264 static jQueryInterface(config) {
6265 return this.each(function () {
6266 const data = Toast.getOrCreateInstance(this, config);
6267 if (typeof config === 'string') {
6268 if (typeof data[config] === 'undefined') {
6269 throw new TypeError(`No method named "${config}"`);
6270 }
6271 data[config](this);
6272 }
6273 });
6274 }
6275 }
6276
6277 /**
6278 * Data API implementation
6279 */
6280
6281 enableDismissTrigger(Toast);
6282
6283 /**
6284 * jQuery
6285 */
6286
6287 defineJQueryPlugin(Toast);
6288
6289 /**
6290 * --------------------------------------------------------------------------
6291 * Bootstrap index.umd.js
6292 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
6293 * --------------------------------------------------------------------------
6294 */
6295
6296 const index_umd = {
6297 Alert,
6298 Button,
6299 Carousel,
6300 Collapse,
6301 Dropdown,
6302 Modal,
6303 Offcanvas,
6304 Popover,
6305 ScrollSpy,
6306 Tab,
6307 Toast,
6308 Tooltip
6309 };
6310
6311 return index_umd;
6312
6313}));
6314//# sourceMappingURL=bootstrap.bundle.js.map
Note: See TracBrowser for help on using the repository browser.