source: Application/ocrent/wwwroot/lib/bootstrap/js/bootstrap.bundle.js@ f5f7c24

Last change on this file since f5f7c24 was f5f7c24, checked in by 192011 <mk.snicker@…>, 17 months ago

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