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

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

Update repo after prototype presentation
  • Property mode set to 100644
File size: 142.0 KB
Line 
1/*!
2 * Bootstrap v5.3.3 (https://getbootstrap.com/)
3 * Copyright 2011-2024 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
4 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
5 */
6(function (global, factory) {
7 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@popperjs/core')) :
8 typeof define === 'function' && define.amd ? define(['@popperjs/core'], factory) :
9 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.bootstrap = factory(global.Popper));
10})(this, (function (Popper) { 'use strict';
11
12 function _interopNamespaceDefault(e) {
13 const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
14 if (e) {
15 for (const k in e) {
16 if (k !== 'default') {
17 const d = Object.getOwnPropertyDescriptor(e, k);
18 Object.defineProperty(n, k, d.get ? d : {
19 enumerable: true,
20 get: () => e[k]
21 });
22 }
23 }
24 }
25 n.default = e;
26 return Object.freeze(n);
27 }
28
29 const Popper__namespace = /*#__PURE__*/_interopNamespaceDefault(Popper);
30
31 /**
32 * --------------------------------------------------------------------------
33 * Bootstrap dom/data.js
34 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
35 * --------------------------------------------------------------------------
36 */
37
38 /**
39 * Constants
40 */
41
42 const elementMap = new Map();
43 const Data = {
44 set(element, key, instance) {
45 if (!elementMap.has(element)) {
46 elementMap.set(element, new Map());
47 }
48 const instanceMap = elementMap.get(element);
49
50 // make it clear we only want one instance per element
51 // can be removed later when multiple key/instances are fine to be used
52 if (!instanceMap.has(key) && instanceMap.size !== 0) {
53 // eslint-disable-next-line no-console
54 console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);
55 return;
56 }
57 instanceMap.set(key, instance);
58 },
59 get(element, key) {
60 if (elementMap.has(element)) {
61 return elementMap.get(element).get(key) || null;
62 }
63 return null;
64 },
65 remove(element, key) {
66 if (!elementMap.has(element)) {
67 return;
68 }
69 const instanceMap = elementMap.get(element);
70 instanceMap.delete(key);
71
72 // free up element references if there are no instances left for an element
73 if (instanceMap.size === 0) {
74 elementMap.delete(element);
75 }
76 }
77 };
78
79 /**
80 * --------------------------------------------------------------------------
81 * Bootstrap util/index.js
82 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
83 * --------------------------------------------------------------------------
84 */
85
86 const MAX_UID = 1000000;
87 const MILLISECONDS_MULTIPLIER = 1000;
88 const TRANSITION_END = 'transitionend';
89
90 /**
91 * Properly escape IDs selectors to handle weird IDs
92 * @param {string} selector
93 * @returns {string}
94 */
95 const parseSelector = selector => {
96 if (selector && window.CSS && window.CSS.escape) {
97 // document.querySelector needs escaping to handle IDs (html5+) containing for instance /
98 selector = selector.replace(/#([^\s"#']+)/g, (match, id) => `#${CSS.escape(id)}`);
99 }
100 return selector;
101 };
102
103 // Shout-out Angus Croll (https://goo.gl/pxwQGp)
104 const toType = object => {
105 if (object === null || object === undefined) {
106 return `${object}`;
107 }
108 return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase();
109 };
110
111 /**
112 * Public Util API
113 */
114
115 const getUID = prefix => {
116 do {
117 prefix += Math.floor(Math.random() * MAX_UID);
118 } while (document.getElementById(prefix));
119 return prefix;
120 };
121 const getTransitionDurationFromElement = element => {
122 if (!element) {
123 return 0;
124 }
125
126 // Get transition-duration of the element
127 let {
128 transitionDuration,
129 transitionDelay
130 } = window.getComputedStyle(element);
131 const floatTransitionDuration = Number.parseFloat(transitionDuration);
132 const floatTransitionDelay = Number.parseFloat(transitionDelay);
133
134 // Return 0 if element or transition duration is not found
135 if (!floatTransitionDuration && !floatTransitionDelay) {
136 return 0;
137 }
138
139 // If multiple durations are defined, take the first
140 transitionDuration = transitionDuration.split(',')[0];
141 transitionDelay = transitionDelay.split(',')[0];
142 return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
143 };
144 const triggerTransitionEnd = element => {
145 element.dispatchEvent(new Event(TRANSITION_END));
146 };
147 const isElement = object => {
148 if (!object || typeof object !== 'object') {
149 return false;
150 }
151 if (typeof object.jquery !== 'undefined') {
152 object = object[0];
153 }
154 return typeof object.nodeType !== 'undefined';
155 };
156 const getElement = object => {
157 // it's a jQuery object or a node element
158 if (isElement(object)) {
159 return object.jquery ? object[0] : object;
160 }
161 if (typeof object === 'string' && object.length > 0) {
162 return document.querySelector(parseSelector(object));
163 }
164 return null;
165 };
166 const isVisible = element => {
167 if (!isElement(element) || element.getClientRects().length === 0) {
168 return false;
169 }
170 const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible';
171 // Handle `details` element as its content may falsie appear visible when it is closed
172 const closedDetails = element.closest('details:not([open])');
173 if (!closedDetails) {
174 return elementIsVisible;
175 }
176 if (closedDetails !== element) {
177 const summary = element.closest('summary');
178 if (summary && summary.parentNode !== closedDetails) {
179 return false;
180 }
181 if (summary === null) {
182 return false;
183 }
184 }
185 return elementIsVisible;
186 };
187 const isDisabled = element => {
188 if (!element || element.nodeType !== Node.ELEMENT_NODE) {
189 return true;
190 }
191 if (element.classList.contains('disabled')) {
192 return true;
193 }
194 if (typeof element.disabled !== 'undefined') {
195 return element.disabled;
196 }
197 return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
198 };
199 const findShadowRoot = element => {
200 if (!document.documentElement.attachShadow) {
201 return null;
202 }
203
204 // Can find the shadow root otherwise it'll return the document
205 if (typeof element.getRootNode === 'function') {
206 const root = element.getRootNode();
207 return root instanceof ShadowRoot ? root : null;
208 }
209 if (element instanceof ShadowRoot) {
210 return element;
211 }
212
213 // when we don't find a shadow root
214 if (!element.parentNode) {
215 return null;
216 }
217 return findShadowRoot(element.parentNode);
218 };
219 const noop = () => {};
220
221 /**
222 * Trick to restart an element's animation
223 *
224 * @param {HTMLElement} element
225 * @return void
226 *
227 * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
228 */
229 const reflow = element => {
230 element.offsetHeight; // eslint-disable-line no-unused-expressions
231 };
232 const getjQuery = () => {
233 if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
234 return window.jQuery;
235 }
236 return null;
237 };
238 const DOMContentLoadedCallbacks = [];
239 const onDOMContentLoaded = callback => {
240 if (document.readyState === 'loading') {
241 // add listener on the first call when the document is in loading state
242 if (!DOMContentLoadedCallbacks.length) {
243 document.addEventListener('DOMContentLoaded', () => {
244 for (const callback of DOMContentLoadedCallbacks) {
245 callback();
246 }
247 });
248 }
249 DOMContentLoadedCallbacks.push(callback);
250 } else {
251 callback();
252 }
253 };
254 const isRTL = () => document.documentElement.dir === 'rtl';
255 const defineJQueryPlugin = plugin => {
256 onDOMContentLoaded(() => {
257 const $ = getjQuery();
258 /* istanbul ignore if */
259 if ($) {
260 const name = plugin.NAME;
261 const JQUERY_NO_CONFLICT = $.fn[name];
262 $.fn[name] = plugin.jQueryInterface;
263 $.fn[name].Constructor = plugin;
264 $.fn[name].noConflict = () => {
265 $.fn[name] = JQUERY_NO_CONFLICT;
266 return plugin.jQueryInterface;
267 };
268 }
269 });
270 };
271 const execute = (possibleCallback, args = [], defaultValue = possibleCallback) => {
272 return typeof possibleCallback === 'function' ? possibleCallback(...args) : defaultValue;
273 };
274 const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
275 if (!waitForTransition) {
276 execute(callback);
277 return;
278 }
279 const durationPadding = 5;
280 const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
281 let called = false;
282 const handler = ({
283 target
284 }) => {
285 if (target !== transitionElement) {
286 return;
287 }
288 called = true;
289 transitionElement.removeEventListener(TRANSITION_END, handler);
290 execute(callback);
291 };
292 transitionElement.addEventListener(TRANSITION_END, handler);
293 setTimeout(() => {
294 if (!called) {
295 triggerTransitionEnd(transitionElement);
296 }
297 }, emulatedDuration);
298 };
299
300 /**
301 * Return the previous/next element of a list.
302 *
303 * @param {array} list The list of elements
304 * @param activeElement The active element
305 * @param shouldGetNext Choose to get next or previous element
306 * @param isCycleAllowed
307 * @return {Element|elem} The proper element
308 */
309 const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
310 const listLength = list.length;
311 let index = list.indexOf(activeElement);
312
313 // if the element does not exist in the list return an element
314 // depending on the direction and if cycle is allowed
315 if (index === -1) {
316 return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];
317 }
318 index += shouldGetNext ? 1 : -1;
319 if (isCycleAllowed) {
320 index = (index + listLength) % listLength;
321 }
322 return list[Math.max(0, Math.min(index, listLength - 1))];
323 };
324
325 /**
326 * --------------------------------------------------------------------------
327 * Bootstrap dom/event-handler.js
328 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
329 * --------------------------------------------------------------------------
330 */
331
332
333 /**
334 * Constants
335 */
336
337 const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
338 const stripNameRegex = /\..*/;
339 const stripUidRegex = /::\d+$/;
340 const eventRegistry = {}; // Events storage
341 let uidEvent = 1;
342 const customEvents = {
343 mouseenter: 'mouseover',
344 mouseleave: 'mouseout'
345 };
346 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']);
347
348 /**
349 * Private methods
350 */
351
352 function makeEventUid(element, uid) {
353 return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
354 }
355 function getElementEvents(element) {
356 const uid = makeEventUid(element);
357 element.uidEvent = uid;
358 eventRegistry[uid] = eventRegistry[uid] || {};
359 return eventRegistry[uid];
360 }
361 function bootstrapHandler(element, fn) {
362 return function handler(event) {
363 hydrateObj(event, {
364 delegateTarget: element
365 });
366 if (handler.oneOff) {
367 EventHandler.off(element, event.type, fn);
368 }
369 return fn.apply(element, [event]);
370 };
371 }
372 function bootstrapDelegationHandler(element, selector, fn) {
373 return function handler(event) {
374 const domElements = element.querySelectorAll(selector);
375 for (let {
376 target
377 } = event; target && target !== this; target = target.parentNode) {
378 for (const domElement of domElements) {
379 if (domElement !== target) {
380 continue;
381 }
382 hydrateObj(event, {
383 delegateTarget: target
384 });
385 if (handler.oneOff) {
386 EventHandler.off(element, event.type, selector, fn);
387 }
388 return fn.apply(target, [event]);
389 }
390 }
391 };
392 }
393 function findHandler(events, callable, delegationSelector = null) {
394 return Object.values(events).find(event => event.callable === callable && event.delegationSelector === delegationSelector);
395 }
396 function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
397 const isDelegated = typeof handler === 'string';
398 // TODO: tooltip passes `false` instead of selector, so we need to check
399 const callable = isDelegated ? delegationFunction : handler || delegationFunction;
400 let typeEvent = getTypeEvent(originalTypeEvent);
401 if (!nativeEvents.has(typeEvent)) {
402 typeEvent = originalTypeEvent;
403 }
404 return [isDelegated, callable, typeEvent];
405 }
406 function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
407 if (typeof originalTypeEvent !== 'string' || !element) {
408 return;
409 }
410 let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
411
412 // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
413 // this prevents the handler from being dispatched the same way as mouseover or mouseout does
414 if (originalTypeEvent in customEvents) {
415 const wrapFunction = fn => {
416 return function (event) {
417 if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
418 return fn.call(this, event);
419 }
420 };
421 };
422 callable = wrapFunction(callable);
423 }
424 const events = getElementEvents(element);
425 const handlers = events[typeEvent] || (events[typeEvent] = {});
426 const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
427 if (previousFunction) {
428 previousFunction.oneOff = previousFunction.oneOff && oneOff;
429 return;
430 }
431 const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''));
432 const fn = isDelegated ? bootstrapDelegationHandler(element, handler, callable) : bootstrapHandler(element, callable);
433 fn.delegationSelector = isDelegated ? handler : null;
434 fn.callable = callable;
435 fn.oneOff = oneOff;
436 fn.uidEvent = uid;
437 handlers[uid] = fn;
438 element.addEventListener(typeEvent, fn, isDelegated);
439 }
440 function removeHandler(element, events, typeEvent, handler, delegationSelector) {
441 const fn = findHandler(events[typeEvent], handler, delegationSelector);
442 if (!fn) {
443 return;
444 }
445 element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
446 delete events[typeEvent][fn.uidEvent];
447 }
448 function removeNamespacedHandlers(element, events, typeEvent, namespace) {
449 const storeElementEvent = events[typeEvent] || {};
450 for (const [handlerKey, event] of Object.entries(storeElementEvent)) {
451 if (handlerKey.includes(namespace)) {
452 removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
453 }
454 }
455 }
456 function getTypeEvent(event) {
457 // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
458 event = event.replace(stripNameRegex, '');
459 return customEvents[event] || event;
460 }
461 const EventHandler = {
462 on(element, event, handler, delegationFunction) {
463 addHandler(element, event, handler, delegationFunction, false);
464 },
465 one(element, event, handler, delegationFunction) {
466 addHandler(element, event, handler, delegationFunction, true);
467 },
468 off(element, originalTypeEvent, handler, delegationFunction) {
469 if (typeof originalTypeEvent !== 'string' || !element) {
470 return;
471 }
472 const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
473 const inNamespace = typeEvent !== originalTypeEvent;
474 const events = getElementEvents(element);
475 const storeElementEvent = events[typeEvent] || {};
476 const isNamespace = originalTypeEvent.startsWith('.');
477 if (typeof callable !== 'undefined') {
478 // Simplest case: handler is passed, remove that listener ONLY.
479 if (!Object.keys(storeElementEvent).length) {
480 return;
481 }
482 removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
483 return;
484 }
485 if (isNamespace) {
486 for (const elementEvent of Object.keys(events)) {
487 removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
488 }
489 }
490 for (const [keyHandlers, event] of Object.entries(storeElementEvent)) {
491 const handlerKey = keyHandlers.replace(stripUidRegex, '');
492 if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
493 removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
494 }
495 }
496 },
497 trigger(element, event, args) {
498 if (typeof event !== 'string' || !element) {
499 return null;
500 }
501 const $ = getjQuery();
502 const typeEvent = getTypeEvent(event);
503 const inNamespace = event !== typeEvent;
504 let jQueryEvent = null;
505 let bubbles = true;
506 let nativeDispatch = true;
507 let defaultPrevented = false;
508 if (inNamespace && $) {
509 jQueryEvent = $.Event(event, args);
510 $(element).trigger(jQueryEvent);
511 bubbles = !jQueryEvent.isPropagationStopped();
512 nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
513 defaultPrevented = jQueryEvent.isDefaultPrevented();
514 }
515 const evt = hydrateObj(new Event(event, {
516 bubbles,
517 cancelable: true
518 }), args);
519 if (defaultPrevented) {
520 evt.preventDefault();
521 }
522 if (nativeDispatch) {
523 element.dispatchEvent(evt);
524 }
525 if (evt.defaultPrevented && jQueryEvent) {
526 jQueryEvent.preventDefault();
527 }
528 return evt;
529 }
530 };
531 function hydrateObj(obj, meta = {}) {
532 for (const [key, value] of Object.entries(meta)) {
533 try {
534 obj[key] = value;
535 } catch (_unused) {
536 Object.defineProperty(obj, key, {
537 configurable: true,
538 get() {
539 return value;
540 }
541 });
542 }
543 }
544 return obj;
545 }
546
547 /**
548 * --------------------------------------------------------------------------
549 * Bootstrap dom/manipulator.js
550 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
551 * --------------------------------------------------------------------------
552 */
553
554 function normalizeData(value) {
555 if (value === 'true') {
556 return true;
557 }
558 if (value === 'false') {
559 return false;
560 }
561 if (value === Number(value).toString()) {
562 return Number(value);
563 }
564 if (value === '' || value === 'null') {
565 return null;
566 }
567 if (typeof value !== 'string') {
568 return value;
569 }
570 try {
571 return JSON.parse(decodeURIComponent(value));
572 } catch (_unused) {
573 return value;
574 }
575 }
576 function normalizeDataKey(key) {
577 return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`);
578 }
579 const Manipulator = {
580 setDataAttribute(element, key, value) {
581 element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);
582 },
583 removeDataAttribute(element, key) {
584 element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);
585 },
586 getDataAttributes(element) {
587 if (!element) {
588 return {};
589 }
590 const attributes = {};
591 const bsKeys = Object.keys(element.dataset).filter(key => key.startsWith('bs') && !key.startsWith('bsConfig'));
592 for (const key of bsKeys) {
593 let pureKey = key.replace(/^bs/, '');
594 pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
595 attributes[pureKey] = normalizeData(element.dataset[key]);
596 }
597 return attributes;
598 },
599 getDataAttribute(element, key) {
600 return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
601 }
602 };
603
604 /**
605 * --------------------------------------------------------------------------
606 * Bootstrap util/config.js
607 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
608 * --------------------------------------------------------------------------
609 */
610
611
612 /**
613 * Class definition
614 */
615
616 class Config {
617 // Getters
618 static get Default() {
619 return {};
620 }
621 static get DefaultType() {
622 return {};
623 }
624 static get NAME() {
625 throw new Error('You have to implement the static method "NAME", for each component!');
626 }
627 _getConfig(config) {
628 config = this._mergeConfigObj(config);
629 config = this._configAfterMerge(config);
630 this._typeCheckConfig(config);
631 return config;
632 }
633 _configAfterMerge(config) {
634 return config;
635 }
636 _mergeConfigObj(config, element) {
637 const jsonConfig = isElement(element) ? Manipulator.getDataAttribute(element, 'config') : {}; // try to parse
638
639 return {
640 ...this.constructor.Default,
641 ...(typeof jsonConfig === 'object' ? jsonConfig : {}),
642 ...(isElement(element) ? Manipulator.getDataAttributes(element) : {}),
643 ...(typeof config === 'object' ? config : {})
644 };
645 }
646 _typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
647 for (const [property, expectedTypes] of Object.entries(configTypes)) {
648 const value = config[property];
649 const valueType = isElement(value) ? 'element' : toType(value);
650 if (!new RegExp(expectedTypes).test(valueType)) {
651 throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`);
652 }
653 }
654 }
655 }
656
657 /**
658 * --------------------------------------------------------------------------
659 * Bootstrap base-component.js
660 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
661 * --------------------------------------------------------------------------
662 */
663
664
665 /**
666 * Constants
667 */
668
669 const VERSION = '5.3.3';
670
671 /**
672 * Class definition
673 */
674
675 class BaseComponent extends Config {
676 constructor(element, config) {
677 super();
678 element = getElement(element);
679 if (!element) {
680 return;
681 }
682 this._element = element;
683 this._config = this._getConfig(config);
684 Data.set(this._element, this.constructor.DATA_KEY, this);
685 }
686
687 // Public
688 dispose() {
689 Data.remove(this._element, this.constructor.DATA_KEY);
690 EventHandler.off(this._element, this.constructor.EVENT_KEY);
691 for (const propertyName of Object.getOwnPropertyNames(this)) {
692 this[propertyName] = null;
693 }
694 }
695 _queueCallback(callback, element, isAnimated = true) {
696 executeAfterTransition(callback, element, isAnimated);
697 }
698 _getConfig(config) {
699 config = this._mergeConfigObj(config, this._element);
700 config = this._configAfterMerge(config);
701 this._typeCheckConfig(config);
702 return config;
703 }
704
705 // Static
706 static getInstance(element) {
707 return Data.get(getElement(element), this.DATA_KEY);
708 }
709 static getOrCreateInstance(element, config = {}) {
710 return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);
711 }
712 static get VERSION() {
713 return VERSION;
714 }
715 static get DATA_KEY() {
716 return `bs.${this.NAME}`;
717 }
718 static get EVENT_KEY() {
719 return `.${this.DATA_KEY}`;
720 }
721 static eventName(name) {
722 return `${name}${this.EVENT_KEY}`;
723 }
724 }
725
726 /**
727 * --------------------------------------------------------------------------
728 * Bootstrap dom/selector-engine.js
729 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
730 * --------------------------------------------------------------------------
731 */
732
733 const getSelector = element => {
734 let selector = element.getAttribute('data-bs-target');
735 if (!selector || selector === '#') {
736 let hrefAttribute = element.getAttribute('href');
737
738 // The only valid content that could double as a selector are IDs or classes,
739 // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
740 // `document.querySelector` will rightfully complain it is invalid.
741 // See https://github.com/twbs/bootstrap/issues/32273
742 if (!hrefAttribute || !hrefAttribute.includes('#') && !hrefAttribute.startsWith('.')) {
743 return null;
744 }
745
746 // Just in case some CMS puts out a full URL with the anchor appended
747 if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) {
748 hrefAttribute = `#${hrefAttribute.split('#')[1]}`;
749 }
750 selector = hrefAttribute && hrefAttribute !== '#' ? hrefAttribute.trim() : null;
751 }
752 return selector ? selector.split(',').map(sel => parseSelector(sel)).join(',') : null;
753 };
754 const SelectorEngine = {
755 find(selector, element = document.documentElement) {
756 return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
757 },
758 findOne(selector, element = document.documentElement) {
759 return Element.prototype.querySelector.call(element, selector);
760 },
761 children(element, selector) {
762 return [].concat(...element.children).filter(child => child.matches(selector));
763 },
764 parents(element, selector) {
765 const parents = [];
766 let ancestor = element.parentNode.closest(selector);
767 while (ancestor) {
768 parents.push(ancestor);
769 ancestor = ancestor.parentNode.closest(selector);
770 }
771 return parents;
772 },
773 prev(element, selector) {
774 let previous = element.previousElementSibling;
775 while (previous) {
776 if (previous.matches(selector)) {
777 return [previous];
778 }
779 previous = previous.previousElementSibling;
780 }
781 return [];
782 },
783 // TODO: this is now unused; remove later along with prev()
784 next(element, selector) {
785 let next = element.nextElementSibling;
786 while (next) {
787 if (next.matches(selector)) {
788 return [next];
789 }
790 next = next.nextElementSibling;
791 }
792 return [];
793 },
794 focusableChildren(element) {
795 const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(selector => `${selector}:not([tabindex^="-"])`).join(',');
796 return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el));
797 },
798 getSelectorFromElement(element) {
799 const selector = getSelector(element);
800 if (selector) {
801 return SelectorEngine.findOne(selector) ? selector : null;
802 }
803 return null;
804 },
805 getElementFromSelector(element) {
806 const selector = getSelector(element);
807 return selector ? SelectorEngine.findOne(selector) : null;
808 },
809 getMultipleElementsFromSelector(element) {
810 const selector = getSelector(element);
811 return selector ? SelectorEngine.find(selector) : [];
812 }
813 };
814
815 /**
816 * --------------------------------------------------------------------------
817 * Bootstrap util/component-functions.js
818 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
819 * --------------------------------------------------------------------------
820 */
821
822 const enableDismissTrigger = (component, method = 'hide') => {
823 const clickEvent = `click.dismiss${component.EVENT_KEY}`;
824 const name = component.NAME;
825 EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) {
826 if (['A', 'AREA'].includes(this.tagName)) {
827 event.preventDefault();
828 }
829 if (isDisabled(this)) {
830 return;
831 }
832 const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`);
833 const instance = component.getOrCreateInstance(target);
834
835 // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
836 instance[method]();
837 });
838 };
839
840 /**
841 * --------------------------------------------------------------------------
842 * Bootstrap alert.js
843 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
844 * --------------------------------------------------------------------------
845 */
846
847
848 /**
849 * Constants
850 */
851
852 const NAME$f = 'alert';
853 const DATA_KEY$a = 'bs.alert';
854 const EVENT_KEY$b = `.${DATA_KEY$a}`;
855 const EVENT_CLOSE = `close${EVENT_KEY$b}`;
856 const EVENT_CLOSED = `closed${EVENT_KEY$b}`;
857 const CLASS_NAME_FADE$5 = 'fade';
858 const CLASS_NAME_SHOW$8 = 'show';
859
860 /**
861 * Class definition
862 */
863
864 class Alert extends BaseComponent {
865 // Getters
866 static get NAME() {
867 return NAME$f;
868 }
869
870 // Public
871 close() {
872 const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
873 if (closeEvent.defaultPrevented) {
874 return;
875 }
876 this._element.classList.remove(CLASS_NAME_SHOW$8);
877 const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
878 this._queueCallback(() => this._destroyElement(), this._element, isAnimated);
879 }
880
881 // Private
882 _destroyElement() {
883 this._element.remove();
884 EventHandler.trigger(this._element, EVENT_CLOSED);
885 this.dispose();
886 }
887
888 // Static
889 static jQueryInterface(config) {
890 return this.each(function () {
891 const data = Alert.getOrCreateInstance(this);
892 if (typeof config !== 'string') {
893 return;
894 }
895 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
896 throw new TypeError(`No method named "${config}"`);
897 }
898 data[config](this);
899 });
900 }
901 }
902
903 /**
904 * Data API implementation
905 */
906
907 enableDismissTrigger(Alert, 'close');
908
909 /**
910 * jQuery
911 */
912
913 defineJQueryPlugin(Alert);
914
915 /**
916 * --------------------------------------------------------------------------
917 * Bootstrap button.js
918 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
919 * --------------------------------------------------------------------------
920 */
921
922
923 /**
924 * Constants
925 */
926
927 const NAME$e = 'button';
928 const DATA_KEY$9 = 'bs.button';
929 const EVENT_KEY$a = `.${DATA_KEY$9}`;
930 const DATA_API_KEY$6 = '.data-api';
931 const CLASS_NAME_ACTIVE$3 = 'active';
932 const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
933 const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`;
934
935 /**
936 * Class definition
937 */
938
939 class Button extends BaseComponent {
940 // Getters
941 static get NAME() {
942 return NAME$e;
943 }
944
945 // Public
946 toggle() {
947 // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
948 this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3));
949 }
950
951 // Static
952 static jQueryInterface(config) {
953 return this.each(function () {
954 const data = Button.getOrCreateInstance(this);
955 if (config === 'toggle') {
956 data[config]();
957 }
958 });
959 }
960 }
961
962 /**
963 * Data API implementation
964 */
965
966 EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => {
967 event.preventDefault();
968 const button = event.target.closest(SELECTOR_DATA_TOGGLE$5);
969 const data = Button.getOrCreateInstance(button);
970 data.toggle();
971 });
972
973 /**
974 * jQuery
975 */
976
977 defineJQueryPlugin(Button);
978
979 /**
980 * --------------------------------------------------------------------------
981 * Bootstrap util/swipe.js
982 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
983 * --------------------------------------------------------------------------
984 */
985
986
987 /**
988 * Constants
989 */
990
991 const NAME$d = 'swipe';
992 const EVENT_KEY$9 = '.bs.swipe';
993 const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$9}`;
994 const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$9}`;
995 const EVENT_TOUCHEND = `touchend${EVENT_KEY$9}`;
996 const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$9}`;
997 const EVENT_POINTERUP = `pointerup${EVENT_KEY$9}`;
998 const POINTER_TYPE_TOUCH = 'touch';
999 const POINTER_TYPE_PEN = 'pen';
1000 const CLASS_NAME_POINTER_EVENT = 'pointer-event';
1001 const SWIPE_THRESHOLD = 40;
1002 const Default$c = {
1003 endCallback: null,
1004 leftCallback: null,
1005 rightCallback: null
1006 };
1007 const DefaultType$c = {
1008 endCallback: '(function|null)',
1009 leftCallback: '(function|null)',
1010 rightCallback: '(function|null)'
1011 };
1012
1013 /**
1014 * Class definition
1015 */
1016
1017 class Swipe extends Config {
1018 constructor(element, config) {
1019 super();
1020 this._element = element;
1021 if (!element || !Swipe.isSupported()) {
1022 return;
1023 }
1024 this._config = this._getConfig(config);
1025 this._deltaX = 0;
1026 this._supportPointerEvents = Boolean(window.PointerEvent);
1027 this._initEvents();
1028 }
1029
1030 // Getters
1031 static get Default() {
1032 return Default$c;
1033 }
1034 static get DefaultType() {
1035 return DefaultType$c;
1036 }
1037 static get NAME() {
1038 return NAME$d;
1039 }
1040
1041 // Public
1042 dispose() {
1043 EventHandler.off(this._element, EVENT_KEY$9);
1044 }
1045
1046 // Private
1047 _start(event) {
1048 if (!this._supportPointerEvents) {
1049 this._deltaX = event.touches[0].clientX;
1050 return;
1051 }
1052 if (this._eventIsPointerPenTouch(event)) {
1053 this._deltaX = event.clientX;
1054 }
1055 }
1056 _end(event) {
1057 if (this._eventIsPointerPenTouch(event)) {
1058 this._deltaX = event.clientX - this._deltaX;
1059 }
1060 this._handleSwipe();
1061 execute(this._config.endCallback);
1062 }
1063 _move(event) {
1064 this._deltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this._deltaX;
1065 }
1066 _handleSwipe() {
1067 const absDeltaX = Math.abs(this._deltaX);
1068 if (absDeltaX <= SWIPE_THRESHOLD) {
1069 return;
1070 }
1071 const direction = absDeltaX / this._deltaX;
1072 this._deltaX = 0;
1073 if (!direction) {
1074 return;
1075 }
1076 execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback);
1077 }
1078 _initEvents() {
1079 if (this._supportPointerEvents) {
1080 EventHandler.on(this._element, EVENT_POINTERDOWN, event => this._start(event));
1081 EventHandler.on(this._element, EVENT_POINTERUP, event => this._end(event));
1082 this._element.classList.add(CLASS_NAME_POINTER_EVENT);
1083 } else {
1084 EventHandler.on(this._element, EVENT_TOUCHSTART, event => this._start(event));
1085 EventHandler.on(this._element, EVENT_TOUCHMOVE, event => this._move(event));
1086 EventHandler.on(this._element, EVENT_TOUCHEND, event => this._end(event));
1087 }
1088 }
1089 _eventIsPointerPenTouch(event) {
1090 return this._supportPointerEvents && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH);
1091 }
1092
1093 // Static
1094 static isSupported() {
1095 return 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
1096 }
1097 }
1098
1099 /**
1100 * --------------------------------------------------------------------------
1101 * Bootstrap carousel.js
1102 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1103 * --------------------------------------------------------------------------
1104 */
1105
1106
1107 /**
1108 * Constants
1109 */
1110
1111 const NAME$c = 'carousel';
1112 const DATA_KEY$8 = 'bs.carousel';
1113 const EVENT_KEY$8 = `.${DATA_KEY$8}`;
1114 const DATA_API_KEY$5 = '.data-api';
1115 const ARROW_LEFT_KEY$1 = 'ArrowLeft';
1116 const ARROW_RIGHT_KEY$1 = 'ArrowRight';
1117 const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
1118
1119 const ORDER_NEXT = 'next';
1120 const ORDER_PREV = 'prev';
1121 const DIRECTION_LEFT = 'left';
1122 const DIRECTION_RIGHT = 'right';
1123 const EVENT_SLIDE = `slide${EVENT_KEY$8}`;
1124 const EVENT_SLID = `slid${EVENT_KEY$8}`;
1125 const EVENT_KEYDOWN$1 = `keydown${EVENT_KEY$8}`;
1126 const EVENT_MOUSEENTER$1 = `mouseenter${EVENT_KEY$8}`;
1127 const EVENT_MOUSELEAVE$1 = `mouseleave${EVENT_KEY$8}`;
1128 const EVENT_DRAG_START = `dragstart${EVENT_KEY$8}`;
1129 const EVENT_LOAD_DATA_API$3 = `load${EVENT_KEY$8}${DATA_API_KEY$5}`;
1130 const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`;
1131 const CLASS_NAME_CAROUSEL = 'carousel';
1132 const CLASS_NAME_ACTIVE$2 = 'active';
1133 const CLASS_NAME_SLIDE = 'slide';
1134 const CLASS_NAME_END = 'carousel-item-end';
1135 const CLASS_NAME_START = 'carousel-item-start';
1136 const CLASS_NAME_NEXT = 'carousel-item-next';
1137 const CLASS_NAME_PREV = 'carousel-item-prev';
1138 const SELECTOR_ACTIVE = '.active';
1139 const SELECTOR_ITEM = '.carousel-item';
1140 const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_ITEM;
1141 const SELECTOR_ITEM_IMG = '.carousel-item img';
1142 const SELECTOR_INDICATORS = '.carousel-indicators';
1143 const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]';
1144 const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
1145 const KEY_TO_DIRECTION = {
1146 [ARROW_LEFT_KEY$1]: DIRECTION_RIGHT,
1147 [ARROW_RIGHT_KEY$1]: DIRECTION_LEFT
1148 };
1149 const Default$b = {
1150 interval: 5000,
1151 keyboard: true,
1152 pause: 'hover',
1153 ride: false,
1154 touch: true,
1155 wrap: true
1156 };
1157 const DefaultType$b = {
1158 interval: '(number|boolean)',
1159 // TODO:v6 remove boolean support
1160 keyboard: 'boolean',
1161 pause: '(string|boolean)',
1162 ride: '(boolean|string)',
1163 touch: 'boolean',
1164 wrap: 'boolean'
1165 };
1166
1167 /**
1168 * Class definition
1169 */
1170
1171 class Carousel extends BaseComponent {
1172 constructor(element, config) {
1173 super(element, config);
1174 this._interval = null;
1175 this._activeElement = null;
1176 this._isSliding = false;
1177 this.touchTimeout = null;
1178 this._swipeHelper = null;
1179 this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
1180 this._addEventListeners();
1181 if (this._config.ride === CLASS_NAME_CAROUSEL) {
1182 this.cycle();
1183 }
1184 }
1185
1186 // Getters
1187 static get Default() {
1188 return Default$b;
1189 }
1190 static get DefaultType() {
1191 return DefaultType$b;
1192 }
1193 static get NAME() {
1194 return NAME$c;
1195 }
1196
1197 // Public
1198 next() {
1199 this._slide(ORDER_NEXT);
1200 }
1201 nextWhenVisible() {
1202 // FIXME TODO use `document.visibilityState`
1203 // Don't call next when the page isn't visible
1204 // or the carousel or its parent isn't visible
1205 if (!document.hidden && isVisible(this._element)) {
1206 this.next();
1207 }
1208 }
1209 prev() {
1210 this._slide(ORDER_PREV);
1211 }
1212 pause() {
1213 if (this._isSliding) {
1214 triggerTransitionEnd(this._element);
1215 }
1216 this._clearInterval();
1217 }
1218 cycle() {
1219 this._clearInterval();
1220 this._updateInterval();
1221 this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);
1222 }
1223 _maybeEnableCycle() {
1224 if (!this._config.ride) {
1225 return;
1226 }
1227 if (this._isSliding) {
1228 EventHandler.one(this._element, EVENT_SLID, () => this.cycle());
1229 return;
1230 }
1231 this.cycle();
1232 }
1233 to(index) {
1234 const items = this._getItems();
1235 if (index > items.length - 1 || index < 0) {
1236 return;
1237 }
1238 if (this._isSliding) {
1239 EventHandler.one(this._element, EVENT_SLID, () => this.to(index));
1240 return;
1241 }
1242 const activeIndex = this._getItemIndex(this._getActive());
1243 if (activeIndex === index) {
1244 return;
1245 }
1246 const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
1247 this._slide(order, items[index]);
1248 }
1249 dispose() {
1250 if (this._swipeHelper) {
1251 this._swipeHelper.dispose();
1252 }
1253 super.dispose();
1254 }
1255
1256 // Private
1257 _configAfterMerge(config) {
1258 config.defaultInterval = config.interval;
1259 return config;
1260 }
1261 _addEventListeners() {
1262 if (this._config.keyboard) {
1263 EventHandler.on(this._element, EVENT_KEYDOWN$1, event => this._keydown(event));
1264 }
1265 if (this._config.pause === 'hover') {
1266 EventHandler.on(this._element, EVENT_MOUSEENTER$1, () => this.pause());
1267 EventHandler.on(this._element, EVENT_MOUSELEAVE$1, () => this._maybeEnableCycle());
1268 }
1269 if (this._config.touch && Swipe.isSupported()) {
1270 this._addTouchEventListeners();
1271 }
1272 }
1273 _addTouchEventListeners() {
1274 for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {
1275 EventHandler.on(img, EVENT_DRAG_START, event => event.preventDefault());
1276 }
1277 const endCallBack = () => {
1278 if (this._config.pause !== 'hover') {
1279 return;
1280 }
1281
1282 // If it's a touch-enabled device, mouseenter/leave are fired as
1283 // part of the mouse compatibility events on first tap - the carousel
1284 // would stop cycling until user tapped out of it;
1285 // here, we listen for touchend, explicitly pause the carousel
1286 // (as if it's the second time we tap on it, mouseenter compat event
1287 // is NOT fired) and after a timeout (to allow for mouse compatibility
1288 // events to fire) we explicitly restart cycling
1289
1290 this.pause();
1291 if (this.touchTimeout) {
1292 clearTimeout(this.touchTimeout);
1293 }
1294 this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval);
1295 };
1296 const swipeConfig = {
1297 leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
1298 rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
1299 endCallback: endCallBack
1300 };
1301 this._swipeHelper = new Swipe(this._element, swipeConfig);
1302 }
1303 _keydown(event) {
1304 if (/input|textarea/i.test(event.target.tagName)) {
1305 return;
1306 }
1307 const direction = KEY_TO_DIRECTION[event.key];
1308 if (direction) {
1309 event.preventDefault();
1310 this._slide(this._directionToOrder(direction));
1311 }
1312 }
1313 _getItemIndex(element) {
1314 return this._getItems().indexOf(element);
1315 }
1316 _setActiveIndicatorElement(index) {
1317 if (!this._indicatorsElement) {
1318 return;
1319 }
1320 const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
1321 activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);
1322 activeIndicator.removeAttribute('aria-current');
1323 const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement);
1324 if (newActiveIndicator) {
1325 newActiveIndicator.classList.add(CLASS_NAME_ACTIVE$2);
1326 newActiveIndicator.setAttribute('aria-current', 'true');
1327 }
1328 }
1329 _updateInterval() {
1330 const element = this._activeElement || this._getActive();
1331 if (!element) {
1332 return;
1333 }
1334 const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
1335 this._config.interval = elementInterval || this._config.defaultInterval;
1336 }
1337 _slide(order, element = null) {
1338 if (this._isSliding) {
1339 return;
1340 }
1341 const activeElement = this._getActive();
1342 const isNext = order === ORDER_NEXT;
1343 const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);
1344 if (nextElement === activeElement) {
1345 return;
1346 }
1347 const nextElementIndex = this._getItemIndex(nextElement);
1348 const triggerEvent = eventName => {
1349 return EventHandler.trigger(this._element, eventName, {
1350 relatedTarget: nextElement,
1351 direction: this._orderToDirection(order),
1352 from: this._getItemIndex(activeElement),
1353 to: nextElementIndex
1354 });
1355 };
1356 const slideEvent = triggerEvent(EVENT_SLIDE);
1357 if (slideEvent.defaultPrevented) {
1358 return;
1359 }
1360 if (!activeElement || !nextElement) {
1361 // Some weirdness is happening, so we bail
1362 // TODO: change tests that use empty divs to avoid this check
1363 return;
1364 }
1365 const isCycling = Boolean(this._interval);
1366 this.pause();
1367 this._isSliding = true;
1368 this._setActiveIndicatorElement(nextElementIndex);
1369 this._activeElement = nextElement;
1370 const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
1371 const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
1372 nextElement.classList.add(orderClassName);
1373 reflow(nextElement);
1374 activeElement.classList.add(directionalClassName);
1375 nextElement.classList.add(directionalClassName);
1376 const completeCallBack = () => {
1377 nextElement.classList.remove(directionalClassName, orderClassName);
1378 nextElement.classList.add(CLASS_NAME_ACTIVE$2);
1379 activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
1380 this._isSliding = false;
1381 triggerEvent(EVENT_SLID);
1382 };
1383 this._queueCallback(completeCallBack, activeElement, this._isAnimated());
1384 if (isCycling) {
1385 this.cycle();
1386 }
1387 }
1388 _isAnimated() {
1389 return this._element.classList.contains(CLASS_NAME_SLIDE);
1390 }
1391 _getActive() {
1392 return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
1393 }
1394 _getItems() {
1395 return SelectorEngine.find(SELECTOR_ITEM, this._element);
1396 }
1397 _clearInterval() {
1398 if (this._interval) {
1399 clearInterval(this._interval);
1400 this._interval = null;
1401 }
1402 }
1403 _directionToOrder(direction) {
1404 if (isRTL()) {
1405 return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
1406 }
1407 return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
1408 }
1409 _orderToDirection(order) {
1410 if (isRTL()) {
1411 return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
1412 }
1413 return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
1414 }
1415
1416 // Static
1417 static jQueryInterface(config) {
1418 return this.each(function () {
1419 const data = Carousel.getOrCreateInstance(this, config);
1420 if (typeof config === 'number') {
1421 data.to(config);
1422 return;
1423 }
1424 if (typeof config === 'string') {
1425 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
1426 throw new TypeError(`No method named "${config}"`);
1427 }
1428 data[config]();
1429 }
1430 });
1431 }
1432 }
1433
1434 /**
1435 * Data API implementation
1436 */
1437
1438 EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, function (event) {
1439 const target = SelectorEngine.getElementFromSelector(this);
1440 if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
1441 return;
1442 }
1443 event.preventDefault();
1444 const carousel = Carousel.getOrCreateInstance(target);
1445 const slideIndex = this.getAttribute('data-bs-slide-to');
1446 if (slideIndex) {
1447 carousel.to(slideIndex);
1448 carousel._maybeEnableCycle();
1449 return;
1450 }
1451 if (Manipulator.getDataAttribute(this, 'slide') === 'next') {
1452 carousel.next();
1453 carousel._maybeEnableCycle();
1454 return;
1455 }
1456 carousel.prev();
1457 carousel._maybeEnableCycle();
1458 });
1459 EventHandler.on(window, EVENT_LOAD_DATA_API$3, () => {
1460 const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
1461 for (const carousel of carousels) {
1462 Carousel.getOrCreateInstance(carousel);
1463 }
1464 });
1465
1466 /**
1467 * jQuery
1468 */
1469
1470 defineJQueryPlugin(Carousel);
1471
1472 /**
1473 * --------------------------------------------------------------------------
1474 * Bootstrap collapse.js
1475 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1476 * --------------------------------------------------------------------------
1477 */
1478
1479
1480 /**
1481 * Constants
1482 */
1483
1484 const NAME$b = 'collapse';
1485 const DATA_KEY$7 = 'bs.collapse';
1486 const EVENT_KEY$7 = `.${DATA_KEY$7}`;
1487 const DATA_API_KEY$4 = '.data-api';
1488 const EVENT_SHOW$6 = `show${EVENT_KEY$7}`;
1489 const EVENT_SHOWN$6 = `shown${EVENT_KEY$7}`;
1490 const EVENT_HIDE$6 = `hide${EVENT_KEY$7}`;
1491 const EVENT_HIDDEN$6 = `hidden${EVENT_KEY$7}`;
1492 const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`;
1493 const CLASS_NAME_SHOW$7 = 'show';
1494 const CLASS_NAME_COLLAPSE = 'collapse';
1495 const CLASS_NAME_COLLAPSING = 'collapsing';
1496 const CLASS_NAME_COLLAPSED = 'collapsed';
1497 const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`;
1498 const CLASS_NAME_HORIZONTAL = 'collapse-horizontal';
1499 const WIDTH = 'width';
1500 const HEIGHT = 'height';
1501 const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';
1502 const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]';
1503 const Default$a = {
1504 parent: null,
1505 toggle: true
1506 };
1507 const DefaultType$a = {
1508 parent: '(null|element)',
1509 toggle: 'boolean'
1510 };
1511
1512 /**
1513 * Class definition
1514 */
1515
1516 class Collapse extends BaseComponent {
1517 constructor(element, config) {
1518 super(element, config);
1519 this._isTransitioning = false;
1520 this._triggerArray = [];
1521 const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);
1522 for (const elem of toggleList) {
1523 const selector = SelectorEngine.getSelectorFromElement(elem);
1524 const filterElement = SelectorEngine.find(selector).filter(foundElement => foundElement === this._element);
1525 if (selector !== null && filterElement.length) {
1526 this._triggerArray.push(elem);
1527 }
1528 }
1529 this._initializeChildren();
1530 if (!this._config.parent) {
1531 this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());
1532 }
1533 if (this._config.toggle) {
1534 this.toggle();
1535 }
1536 }
1537
1538 // Getters
1539 static get Default() {
1540 return Default$a;
1541 }
1542 static get DefaultType() {
1543 return DefaultType$a;
1544 }
1545 static get NAME() {
1546 return NAME$b;
1547 }
1548
1549 // Public
1550 toggle() {
1551 if (this._isShown()) {
1552 this.hide();
1553 } else {
1554 this.show();
1555 }
1556 }
1557 show() {
1558 if (this._isTransitioning || this._isShown()) {
1559 return;
1560 }
1561 let activeChildren = [];
1562
1563 // find active children
1564 if (this._config.parent) {
1565 activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES).filter(element => element !== this._element).map(element => Collapse.getOrCreateInstance(element, {
1566 toggle: false
1567 }));
1568 }
1569 if (activeChildren.length && activeChildren[0]._isTransitioning) {
1570 return;
1571 }
1572 const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$6);
1573 if (startEvent.defaultPrevented) {
1574 return;
1575 }
1576 for (const activeInstance of activeChildren) {
1577 activeInstance.hide();
1578 }
1579 const dimension = this._getDimension();
1580 this._element.classList.remove(CLASS_NAME_COLLAPSE);
1581 this._element.classList.add(CLASS_NAME_COLLAPSING);
1582 this._element.style[dimension] = 0;
1583 this._addAriaAndCollapsedClass(this._triggerArray, true);
1584 this._isTransitioning = true;
1585 const complete = () => {
1586 this._isTransitioning = false;
1587 this._element.classList.remove(CLASS_NAME_COLLAPSING);
1588 this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
1589 this._element.style[dimension] = '';
1590 EventHandler.trigger(this._element, EVENT_SHOWN$6);
1591 };
1592 const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
1593 const scrollSize = `scroll${capitalizedDimension}`;
1594 this._queueCallback(complete, this._element, true);
1595 this._element.style[dimension] = `${this._element[scrollSize]}px`;
1596 }
1597 hide() {
1598 if (this._isTransitioning || !this._isShown()) {
1599 return;
1600 }
1601 const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6);
1602 if (startEvent.defaultPrevented) {
1603 return;
1604 }
1605 const dimension = this._getDimension();
1606 this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;
1607 reflow(this._element);
1608 this._element.classList.add(CLASS_NAME_COLLAPSING);
1609 this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
1610 for (const trigger of this._triggerArray) {
1611 const element = SelectorEngine.getElementFromSelector(trigger);
1612 if (element && !this._isShown(element)) {
1613 this._addAriaAndCollapsedClass([trigger], false);
1614 }
1615 }
1616 this._isTransitioning = true;
1617 const complete = () => {
1618 this._isTransitioning = false;
1619 this._element.classList.remove(CLASS_NAME_COLLAPSING);
1620 this._element.classList.add(CLASS_NAME_COLLAPSE);
1621 EventHandler.trigger(this._element, EVENT_HIDDEN$6);
1622 };
1623 this._element.style[dimension] = '';
1624 this._queueCallback(complete, this._element, true);
1625 }
1626 _isShown(element = this._element) {
1627 return element.classList.contains(CLASS_NAME_SHOW$7);
1628 }
1629
1630 // Private
1631 _configAfterMerge(config) {
1632 config.toggle = Boolean(config.toggle); // Coerce string values
1633 config.parent = getElement(config.parent);
1634 return config;
1635 }
1636 _getDimension() {
1637 return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;
1638 }
1639 _initializeChildren() {
1640 if (!this._config.parent) {
1641 return;
1642 }
1643 const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE$4);
1644 for (const element of children) {
1645 const selected = SelectorEngine.getElementFromSelector(element);
1646 if (selected) {
1647 this._addAriaAndCollapsedClass([element], this._isShown(selected));
1648 }
1649 }
1650 }
1651 _getFirstLevelChildren(selector) {
1652 const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
1653 // remove children if greater depth
1654 return SelectorEngine.find(selector, this._config.parent).filter(element => !children.includes(element));
1655 }
1656 _addAriaAndCollapsedClass(triggerArray, isOpen) {
1657 if (!triggerArray.length) {
1658 return;
1659 }
1660 for (const element of triggerArray) {
1661 element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen);
1662 element.setAttribute('aria-expanded', isOpen);
1663 }
1664 }
1665
1666 // Static
1667 static jQueryInterface(config) {
1668 const _config = {};
1669 if (typeof config === 'string' && /show|hide/.test(config)) {
1670 _config.toggle = false;
1671 }
1672 return this.each(function () {
1673 const data = Collapse.getOrCreateInstance(this, _config);
1674 if (typeof config === 'string') {
1675 if (typeof data[config] === 'undefined') {
1676 throw new TypeError(`No method named "${config}"`);
1677 }
1678 data[config]();
1679 }
1680 });
1681 }
1682 }
1683
1684 /**
1685 * Data API implementation
1686 */
1687
1688 EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {
1689 // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
1690 if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
1691 event.preventDefault();
1692 }
1693 for (const element of SelectorEngine.getMultipleElementsFromSelector(this)) {
1694 Collapse.getOrCreateInstance(element, {
1695 toggle: false
1696 }).toggle();
1697 }
1698 });
1699
1700 /**
1701 * jQuery
1702 */
1703
1704 defineJQueryPlugin(Collapse);
1705
1706 /**
1707 * --------------------------------------------------------------------------
1708 * Bootstrap dropdown.js
1709 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1710 * --------------------------------------------------------------------------
1711 */
1712
1713
1714 /**
1715 * Constants
1716 */
1717
1718 const NAME$a = 'dropdown';
1719 const DATA_KEY$6 = 'bs.dropdown';
1720 const EVENT_KEY$6 = `.${DATA_KEY$6}`;
1721 const DATA_API_KEY$3 = '.data-api';
1722 const ESCAPE_KEY$2 = 'Escape';
1723 const TAB_KEY$1 = 'Tab';
1724 const ARROW_UP_KEY$1 = 'ArrowUp';
1725 const ARROW_DOWN_KEY$1 = 'ArrowDown';
1726 const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button
1727
1728 const EVENT_HIDE$5 = `hide${EVENT_KEY$6}`;
1729 const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$6}`;
1730 const EVENT_SHOW$5 = `show${EVENT_KEY$6}`;
1731 const EVENT_SHOWN$5 = `shown${EVENT_KEY$6}`;
1732 const EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`;
1733 const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$6}${DATA_API_KEY$3}`;
1734 const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$6}${DATA_API_KEY$3}`;
1735 const CLASS_NAME_SHOW$6 = 'show';
1736 const CLASS_NAME_DROPUP = 'dropup';
1737 const CLASS_NAME_DROPEND = 'dropend';
1738 const CLASS_NAME_DROPSTART = 'dropstart';
1739 const CLASS_NAME_DROPUP_CENTER = 'dropup-center';
1740 const CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center';
1741 const SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)';
1742 const SELECTOR_DATA_TOGGLE_SHOWN = `${SELECTOR_DATA_TOGGLE$3}.${CLASS_NAME_SHOW$6}`;
1743 const SELECTOR_MENU = '.dropdown-menu';
1744 const SELECTOR_NAVBAR = '.navbar';
1745 const SELECTOR_NAVBAR_NAV = '.navbar-nav';
1746 const SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)';
1747 const PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start';
1748 const PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end';
1749 const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start';
1750 const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';
1751 const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';
1752 const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';
1753 const PLACEMENT_TOPCENTER = 'top';
1754 const PLACEMENT_BOTTOMCENTER = 'bottom';
1755 const Default$9 = {
1756 autoClose: true,
1757 boundary: 'clippingParents',
1758 display: 'dynamic',
1759 offset: [0, 2],
1760 popperConfig: null,
1761 reference: 'toggle'
1762 };
1763 const DefaultType$9 = {
1764 autoClose: '(boolean|string)',
1765 boundary: '(string|element)',
1766 display: 'string',
1767 offset: '(array|string|function)',
1768 popperConfig: '(null|object|function)',
1769 reference: '(string|element|object)'
1770 };
1771
1772 /**
1773 * Class definition
1774 */
1775
1776 class Dropdown extends BaseComponent {
1777 constructor(element, config) {
1778 super(element, config);
1779 this._popper = null;
1780 this._parent = this._element.parentNode; // dropdown wrapper
1781 // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/
1782 this._menu = SelectorEngine.next(this._element, SELECTOR_MENU)[0] || SelectorEngine.prev(this._element, SELECTOR_MENU)[0] || SelectorEngine.findOne(SELECTOR_MENU, this._parent);
1783 this._inNavbar = this._detectNavbar();
1784 }
1785
1786 // Getters
1787 static get Default() {
1788 return Default$9;
1789 }
1790 static get DefaultType() {
1791 return DefaultType$9;
1792 }
1793 static get NAME() {
1794 return NAME$a;
1795 }
1796
1797 // Public
1798 toggle() {
1799 return this._isShown() ? this.hide() : this.show();
1800 }
1801 show() {
1802 if (isDisabled(this._element) || this._isShown()) {
1803 return;
1804 }
1805 const relatedTarget = {
1806 relatedTarget: this._element
1807 };
1808 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$5, relatedTarget);
1809 if (showEvent.defaultPrevented) {
1810 return;
1811 }
1812 this._createPopper();
1813
1814 // If this is a touch-enabled device we add extra
1815 // empty mouseover listeners to the body's immediate children;
1816 // only needed because of broken event delegation on iOS
1817 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
1818 if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) {
1819 for (const element of [].concat(...document.body.children)) {
1820 EventHandler.on(element, 'mouseover', noop);
1821 }
1822 }
1823 this._element.focus();
1824 this._element.setAttribute('aria-expanded', true);
1825 this._menu.classList.add(CLASS_NAME_SHOW$6);
1826 this._element.classList.add(CLASS_NAME_SHOW$6);
1827 EventHandler.trigger(this._element, EVENT_SHOWN$5, relatedTarget);
1828 }
1829 hide() {
1830 if (isDisabled(this._element) || !this._isShown()) {
1831 return;
1832 }
1833 const relatedTarget = {
1834 relatedTarget: this._element
1835 };
1836 this._completeHide(relatedTarget);
1837 }
1838 dispose() {
1839 if (this._popper) {
1840 this._popper.destroy();
1841 }
1842 super.dispose();
1843 }
1844 update() {
1845 this._inNavbar = this._detectNavbar();
1846 if (this._popper) {
1847 this._popper.update();
1848 }
1849 }
1850
1851 // Private
1852 _completeHide(relatedTarget) {
1853 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$5, relatedTarget);
1854 if (hideEvent.defaultPrevented) {
1855 return;
1856 }
1857
1858 // If this is a touch-enabled device we remove the extra
1859 // empty mouseover listeners we added for iOS support
1860 if ('ontouchstart' in document.documentElement) {
1861 for (const element of [].concat(...document.body.children)) {
1862 EventHandler.off(element, 'mouseover', noop);
1863 }
1864 }
1865 if (this._popper) {
1866 this._popper.destroy();
1867 }
1868 this._menu.classList.remove(CLASS_NAME_SHOW$6);
1869 this._element.classList.remove(CLASS_NAME_SHOW$6);
1870 this._element.setAttribute('aria-expanded', 'false');
1871 Manipulator.removeDataAttribute(this._menu, 'popper');
1872 EventHandler.trigger(this._element, EVENT_HIDDEN$5, relatedTarget);
1873 }
1874 _getConfig(config) {
1875 config = super._getConfig(config);
1876 if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') {
1877 // Popper virtual elements require a getBoundingClientRect method
1878 throw new TypeError(`${NAME$a.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);
1879 }
1880 return config;
1881 }
1882 _createPopper() {
1883 if (typeof Popper__namespace === 'undefined') {
1884 throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)');
1885 }
1886 let referenceElement = this._element;
1887 if (this._config.reference === 'parent') {
1888 referenceElement = this._parent;
1889 } else if (isElement(this._config.reference)) {
1890 referenceElement = getElement(this._config.reference);
1891 } else if (typeof this._config.reference === 'object') {
1892 referenceElement = this._config.reference;
1893 }
1894 const popperConfig = this._getPopperConfig();
1895 this._popper = Popper__namespace.createPopper(referenceElement, this._menu, popperConfig);
1896 }
1897 _isShown() {
1898 return this._menu.classList.contains(CLASS_NAME_SHOW$6);
1899 }
1900 _getPlacement() {
1901 const parentDropdown = this._parent;
1902 if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
1903 return PLACEMENT_RIGHT;
1904 }
1905 if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {
1906 return PLACEMENT_LEFT;
1907 }
1908 if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) {
1909 return PLACEMENT_TOPCENTER;
1910 }
1911 if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENTER)) {
1912 return PLACEMENT_BOTTOMCENTER;
1913 }
1914
1915 // We need to trim the value because custom properties can also include spaces
1916 const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end';
1917 if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {
1918 return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;
1919 }
1920 return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;
1921 }
1922 _detectNavbar() {
1923 return this._element.closest(SELECTOR_NAVBAR) !== null;
1924 }
1925 _getOffset() {
1926 const {
1927 offset
1928 } = this._config;
1929 if (typeof offset === 'string') {
1930 return offset.split(',').map(value => Number.parseInt(value, 10));
1931 }
1932 if (typeof offset === 'function') {
1933 return popperData => offset(popperData, this._element);
1934 }
1935 return offset;
1936 }
1937 _getPopperConfig() {
1938 const defaultBsPopperConfig = {
1939 placement: this._getPlacement(),
1940 modifiers: [{
1941 name: 'preventOverflow',
1942 options: {
1943 boundary: this._config.boundary
1944 }
1945 }, {
1946 name: 'offset',
1947 options: {
1948 offset: this._getOffset()
1949 }
1950 }]
1951 };
1952
1953 // Disable Popper if we have a static display or Dropdown is in Navbar
1954 if (this._inNavbar || this._config.display === 'static') {
1955 Manipulator.setDataAttribute(this._menu, 'popper', 'static'); // TODO: v6 remove
1956 defaultBsPopperConfig.modifiers = [{
1957 name: 'applyStyles',
1958 enabled: false
1959 }];
1960 }
1961 return {
1962 ...defaultBsPopperConfig,
1963 ...execute(this._config.popperConfig, [defaultBsPopperConfig])
1964 };
1965 }
1966 _selectMenuItem({
1967 key,
1968 target
1969 }) {
1970 const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(element => isVisible(element));
1971 if (!items.length) {
1972 return;
1973 }
1974
1975 // if target isn't included in items (e.g. when expanding the dropdown)
1976 // allow cycling to get the last item in case key equals ARROW_UP_KEY
1977 getNextActiveElement(items, target, key === ARROW_DOWN_KEY$1, !items.includes(target)).focus();
1978 }
1979
1980 // Static
1981 static jQueryInterface(config) {
1982 return this.each(function () {
1983 const data = Dropdown.getOrCreateInstance(this, config);
1984 if (typeof config !== 'string') {
1985 return;
1986 }
1987 if (typeof data[config] === 'undefined') {
1988 throw new TypeError(`No method named "${config}"`);
1989 }
1990 data[config]();
1991 });
1992 }
1993 static clearMenus(event) {
1994 if (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1) {
1995 return;
1996 }
1997 const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN);
1998 for (const toggle of openToggles) {
1999 const context = Dropdown.getInstance(toggle);
2000 if (!context || context._config.autoClose === false) {
2001 continue;
2002 }
2003 const composedPath = event.composedPath();
2004 const isMenuTarget = composedPath.includes(context._menu);
2005 if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) {
2006 continue;
2007 }
2008
2009 // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu
2010 if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) {
2011 continue;
2012 }
2013 const relatedTarget = {
2014 relatedTarget: context._element
2015 };
2016 if (event.type === 'click') {
2017 relatedTarget.clickEvent = event;
2018 }
2019 context._completeHide(relatedTarget);
2020 }
2021 }
2022 static dataApiKeydownHandler(event) {
2023 // If not an UP | DOWN | ESCAPE key => not a dropdown command
2024 // If input/textarea && if key is other than ESCAPE => not a dropdown command
2025
2026 const isInput = /input|textarea/i.test(event.target.tagName);
2027 const isEscapeEvent = event.key === ESCAPE_KEY$2;
2028 const isUpOrDownEvent = [ARROW_UP_KEY$1, ARROW_DOWN_KEY$1].includes(event.key);
2029 if (!isUpOrDownEvent && !isEscapeEvent) {
2030 return;
2031 }
2032 if (isInput && !isEscapeEvent) {
2033 return;
2034 }
2035 event.preventDefault();
2036
2037 // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/
2038 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);
2039 const instance = Dropdown.getOrCreateInstance(getToggleButton);
2040 if (isUpOrDownEvent) {
2041 event.stopPropagation();
2042 instance.show();
2043 instance._selectMenuItem(event);
2044 return;
2045 }
2046 if (instance._isShown()) {
2047 // else is escape and we check if it is shown
2048 event.stopPropagation();
2049 instance.hide();
2050 getToggleButton.focus();
2051 }
2052 }
2053 }
2054
2055 /**
2056 * Data API implementation
2057 */
2058
2059 EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler);
2060 EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler);
2061 EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus);
2062 EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);
2063 EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) {
2064 event.preventDefault();
2065 Dropdown.getOrCreateInstance(this).toggle();
2066 });
2067
2068 /**
2069 * jQuery
2070 */
2071
2072 defineJQueryPlugin(Dropdown);
2073
2074 /**
2075 * --------------------------------------------------------------------------
2076 * Bootstrap util/backdrop.js
2077 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2078 * --------------------------------------------------------------------------
2079 */
2080
2081
2082 /**
2083 * Constants
2084 */
2085
2086 const NAME$9 = 'backdrop';
2087 const CLASS_NAME_FADE$4 = 'fade';
2088 const CLASS_NAME_SHOW$5 = 'show';
2089 const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$9}`;
2090 const Default$8 = {
2091 className: 'modal-backdrop',
2092 clickCallback: null,
2093 isAnimated: false,
2094 isVisible: true,
2095 // if false, we use the backdrop helper without adding any element to the dom
2096 rootElement: 'body' // give the choice to place backdrop under different elements
2097 };
2098 const DefaultType$8 = {
2099 className: 'string',
2100 clickCallback: '(function|null)',
2101 isAnimated: 'boolean',
2102 isVisible: 'boolean',
2103 rootElement: '(element|string)'
2104 };
2105
2106 /**
2107 * Class definition
2108 */
2109
2110 class Backdrop extends Config {
2111 constructor(config) {
2112 super();
2113 this._config = this._getConfig(config);
2114 this._isAppended = false;
2115 this._element = null;
2116 }
2117
2118 // Getters
2119 static get Default() {
2120 return Default$8;
2121 }
2122 static get DefaultType() {
2123 return DefaultType$8;
2124 }
2125 static get NAME() {
2126 return NAME$9;
2127 }
2128
2129 // Public
2130 show(callback) {
2131 if (!this._config.isVisible) {
2132 execute(callback);
2133 return;
2134 }
2135 this._append();
2136 const element = this._getElement();
2137 if (this._config.isAnimated) {
2138 reflow(element);
2139 }
2140 element.classList.add(CLASS_NAME_SHOW$5);
2141 this._emulateAnimation(() => {
2142 execute(callback);
2143 });
2144 }
2145 hide(callback) {
2146 if (!this._config.isVisible) {
2147 execute(callback);
2148 return;
2149 }
2150 this._getElement().classList.remove(CLASS_NAME_SHOW$5);
2151 this._emulateAnimation(() => {
2152 this.dispose();
2153 execute(callback);
2154 });
2155 }
2156 dispose() {
2157 if (!this._isAppended) {
2158 return;
2159 }
2160 EventHandler.off(this._element, EVENT_MOUSEDOWN);
2161 this._element.remove();
2162 this._isAppended = false;
2163 }
2164
2165 // Private
2166 _getElement() {
2167 if (!this._element) {
2168 const backdrop = document.createElement('div');
2169 backdrop.className = this._config.className;
2170 if (this._config.isAnimated) {
2171 backdrop.classList.add(CLASS_NAME_FADE$4);
2172 }
2173 this._element = backdrop;
2174 }
2175 return this._element;
2176 }
2177 _configAfterMerge(config) {
2178 // use getElement() with the default "body" to get a fresh Element on each instantiation
2179 config.rootElement = getElement(config.rootElement);
2180 return config;
2181 }
2182 _append() {
2183 if (this._isAppended) {
2184 return;
2185 }
2186 const element = this._getElement();
2187 this._config.rootElement.append(element);
2188 EventHandler.on(element, EVENT_MOUSEDOWN, () => {
2189 execute(this._config.clickCallback);
2190 });
2191 this._isAppended = true;
2192 }
2193 _emulateAnimation(callback) {
2194 executeAfterTransition(callback, this._getElement(), this._config.isAnimated);
2195 }
2196 }
2197
2198 /**
2199 * --------------------------------------------------------------------------
2200 * Bootstrap util/focustrap.js
2201 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2202 * --------------------------------------------------------------------------
2203 */
2204
2205
2206 /**
2207 * Constants
2208 */
2209
2210 const NAME$8 = 'focustrap';
2211 const DATA_KEY$5 = 'bs.focustrap';
2212 const EVENT_KEY$5 = `.${DATA_KEY$5}`;
2213 const EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$5}`;
2214 const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$5}`;
2215 const TAB_KEY = 'Tab';
2216 const TAB_NAV_FORWARD = 'forward';
2217 const TAB_NAV_BACKWARD = 'backward';
2218 const Default$7 = {
2219 autofocus: true,
2220 trapElement: null // The element to trap focus inside of
2221 };
2222 const DefaultType$7 = {
2223 autofocus: 'boolean',
2224 trapElement: 'element'
2225 };
2226
2227 /**
2228 * Class definition
2229 */
2230
2231 class FocusTrap extends Config {
2232 constructor(config) {
2233 super();
2234 this._config = this._getConfig(config);
2235 this._isActive = false;
2236 this._lastTabNavDirection = null;
2237 }
2238
2239 // Getters
2240 static get Default() {
2241 return Default$7;
2242 }
2243 static get DefaultType() {
2244 return DefaultType$7;
2245 }
2246 static get NAME() {
2247 return NAME$8;
2248 }
2249
2250 // Public
2251 activate() {
2252 if (this._isActive) {
2253 return;
2254 }
2255 if (this._config.autofocus) {
2256 this._config.trapElement.focus();
2257 }
2258 EventHandler.off(document, EVENT_KEY$5); // guard against infinite focus loop
2259 EventHandler.on(document, EVENT_FOCUSIN$2, event => this._handleFocusin(event));
2260 EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event));
2261 this._isActive = true;
2262 }
2263 deactivate() {
2264 if (!this._isActive) {
2265 return;
2266 }
2267 this._isActive = false;
2268 EventHandler.off(document, EVENT_KEY$5);
2269 }
2270
2271 // Private
2272 _handleFocusin(event) {
2273 const {
2274 trapElement
2275 } = this._config;
2276 if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) {
2277 return;
2278 }
2279 const elements = SelectorEngine.focusableChildren(trapElement);
2280 if (elements.length === 0) {
2281 trapElement.focus();
2282 } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {
2283 elements[elements.length - 1].focus();
2284 } else {
2285 elements[0].focus();
2286 }
2287 }
2288 _handleKeydown(event) {
2289 if (event.key !== TAB_KEY) {
2290 return;
2291 }
2292 this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD;
2293 }
2294 }
2295
2296 /**
2297 * --------------------------------------------------------------------------
2298 * Bootstrap util/scrollBar.js
2299 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2300 * --------------------------------------------------------------------------
2301 */
2302
2303
2304 /**
2305 * Constants
2306 */
2307
2308 const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
2309 const SELECTOR_STICKY_CONTENT = '.sticky-top';
2310 const PROPERTY_PADDING = 'padding-right';
2311 const PROPERTY_MARGIN = 'margin-right';
2312
2313 /**
2314 * Class definition
2315 */
2316
2317 class ScrollBarHelper {
2318 constructor() {
2319 this._element = document.body;
2320 }
2321
2322 // Public
2323 getWidth() {
2324 // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
2325 const documentWidth = document.documentElement.clientWidth;
2326 return Math.abs(window.innerWidth - documentWidth);
2327 }
2328 hide() {
2329 const width = this.getWidth();
2330 this._disableOverFlow();
2331 // give padding to element to balance the hidden scrollbar width
2332 this._setElementAttributes(this._element, PROPERTY_PADDING, calculatedValue => calculatedValue + width);
2333 // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
2334 this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, calculatedValue => calculatedValue + width);
2335 this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, calculatedValue => calculatedValue - width);
2336 }
2337 reset() {
2338 this._resetElementAttributes(this._element, 'overflow');
2339 this._resetElementAttributes(this._element, PROPERTY_PADDING);
2340 this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING);
2341 this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN);
2342 }
2343 isOverflowing() {
2344 return this.getWidth() > 0;
2345 }
2346
2347 // Private
2348 _disableOverFlow() {
2349 this._saveInitialAttribute(this._element, 'overflow');
2350 this._element.style.overflow = 'hidden';
2351 }
2352 _setElementAttributes(selector, styleProperty, callback) {
2353 const scrollbarWidth = this.getWidth();
2354 const manipulationCallBack = element => {
2355 if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
2356 return;
2357 }
2358 this._saveInitialAttribute(element, styleProperty);
2359 const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty);
2360 element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`);
2361 };
2362 this._applyManipulationCallback(selector, manipulationCallBack);
2363 }
2364 _saveInitialAttribute(element, styleProperty) {
2365 const actualValue = element.style.getPropertyValue(styleProperty);
2366 if (actualValue) {
2367 Manipulator.setDataAttribute(element, styleProperty, actualValue);
2368 }
2369 }
2370 _resetElementAttributes(selector, styleProperty) {
2371 const manipulationCallBack = element => {
2372 const value = Manipulator.getDataAttribute(element, styleProperty);
2373 // We only want to remove the property if the value is `null`; the value can also be zero
2374 if (value === null) {
2375 element.style.removeProperty(styleProperty);
2376 return;
2377 }
2378 Manipulator.removeDataAttribute(element, styleProperty);
2379 element.style.setProperty(styleProperty, value);
2380 };
2381 this._applyManipulationCallback(selector, manipulationCallBack);
2382 }
2383 _applyManipulationCallback(selector, callBack) {
2384 if (isElement(selector)) {
2385 callBack(selector);
2386 return;
2387 }
2388 for (const sel of SelectorEngine.find(selector, this._element)) {
2389 callBack(sel);
2390 }
2391 }
2392 }
2393
2394 /**
2395 * --------------------------------------------------------------------------
2396 * Bootstrap modal.js
2397 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2398 * --------------------------------------------------------------------------
2399 */
2400
2401
2402 /**
2403 * Constants
2404 */
2405
2406 const NAME$7 = 'modal';
2407 const DATA_KEY$4 = 'bs.modal';
2408 const EVENT_KEY$4 = `.${DATA_KEY$4}`;
2409 const DATA_API_KEY$2 = '.data-api';
2410 const ESCAPE_KEY$1 = 'Escape';
2411 const EVENT_HIDE$4 = `hide${EVENT_KEY$4}`;
2412 const EVENT_HIDE_PREVENTED$1 = `hidePrevented${EVENT_KEY$4}`;
2413 const EVENT_HIDDEN$4 = `hidden${EVENT_KEY$4}`;
2414 const EVENT_SHOW$4 = `show${EVENT_KEY$4}`;
2415 const EVENT_SHOWN$4 = `shown${EVENT_KEY$4}`;
2416 const EVENT_RESIZE$1 = `resize${EVENT_KEY$4}`;
2417 const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY$4}`;
2418 const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$4}`;
2419 const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$4}`;
2420 const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$4}${DATA_API_KEY$2}`;
2421 const CLASS_NAME_OPEN = 'modal-open';
2422 const CLASS_NAME_FADE$3 = 'fade';
2423 const CLASS_NAME_SHOW$4 = 'show';
2424 const CLASS_NAME_STATIC = 'modal-static';
2425 const OPEN_SELECTOR$1 = '.modal.show';
2426 const SELECTOR_DIALOG = '.modal-dialog';
2427 const SELECTOR_MODAL_BODY = '.modal-body';
2428 const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]';
2429 const Default$6 = {
2430 backdrop: true,
2431 focus: true,
2432 keyboard: true
2433 };
2434 const DefaultType$6 = {
2435 backdrop: '(boolean|string)',
2436 focus: 'boolean',
2437 keyboard: 'boolean'
2438 };
2439
2440 /**
2441 * Class definition
2442 */
2443
2444 class Modal extends BaseComponent {
2445 constructor(element, config) {
2446 super(element, config);
2447 this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element);
2448 this._backdrop = this._initializeBackDrop();
2449 this._focustrap = this._initializeFocusTrap();
2450 this._isShown = false;
2451 this._isTransitioning = false;
2452 this._scrollBar = new ScrollBarHelper();
2453 this._addEventListeners();
2454 }
2455
2456 // Getters
2457 static get Default() {
2458 return Default$6;
2459 }
2460 static get DefaultType() {
2461 return DefaultType$6;
2462 }
2463 static get NAME() {
2464 return NAME$7;
2465 }
2466
2467 // Public
2468 toggle(relatedTarget) {
2469 return this._isShown ? this.hide() : this.show(relatedTarget);
2470 }
2471 show(relatedTarget) {
2472 if (this._isShown || this._isTransitioning) {
2473 return;
2474 }
2475 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, {
2476 relatedTarget
2477 });
2478 if (showEvent.defaultPrevented) {
2479 return;
2480 }
2481 this._isShown = true;
2482 this._isTransitioning = true;
2483 this._scrollBar.hide();
2484 document.body.classList.add(CLASS_NAME_OPEN);
2485 this._adjustDialog();
2486 this._backdrop.show(() => this._showElement(relatedTarget));
2487 }
2488 hide() {
2489 if (!this._isShown || this._isTransitioning) {
2490 return;
2491 }
2492 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4);
2493 if (hideEvent.defaultPrevented) {
2494 return;
2495 }
2496 this._isShown = false;
2497 this._isTransitioning = true;
2498 this._focustrap.deactivate();
2499 this._element.classList.remove(CLASS_NAME_SHOW$4);
2500 this._queueCallback(() => this._hideModal(), this._element, this._isAnimated());
2501 }
2502 dispose() {
2503 EventHandler.off(window, EVENT_KEY$4);
2504 EventHandler.off(this._dialog, EVENT_KEY$4);
2505 this._backdrop.dispose();
2506 this._focustrap.deactivate();
2507 super.dispose();
2508 }
2509 handleUpdate() {
2510 this._adjustDialog();
2511 }
2512
2513 // Private
2514 _initializeBackDrop() {
2515 return new Backdrop({
2516 isVisible: Boolean(this._config.backdrop),
2517 // 'static' option will be translated to true, and booleans will keep their value,
2518 isAnimated: this._isAnimated()
2519 });
2520 }
2521 _initializeFocusTrap() {
2522 return new FocusTrap({
2523 trapElement: this._element
2524 });
2525 }
2526 _showElement(relatedTarget) {
2527 // try to append dynamic modal
2528 if (!document.body.contains(this._element)) {
2529 document.body.append(this._element);
2530 }
2531 this._element.style.display = 'block';
2532 this._element.removeAttribute('aria-hidden');
2533 this._element.setAttribute('aria-modal', true);
2534 this._element.setAttribute('role', 'dialog');
2535 this._element.scrollTop = 0;
2536 const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);
2537 if (modalBody) {
2538 modalBody.scrollTop = 0;
2539 }
2540 reflow(this._element);
2541 this._element.classList.add(CLASS_NAME_SHOW$4);
2542 const transitionComplete = () => {
2543 if (this._config.focus) {
2544 this._focustrap.activate();
2545 }
2546 this._isTransitioning = false;
2547 EventHandler.trigger(this._element, EVENT_SHOWN$4, {
2548 relatedTarget
2549 });
2550 };
2551 this._queueCallback(transitionComplete, this._dialog, this._isAnimated());
2552 }
2553 _addEventListeners() {
2554 EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => {
2555 if (event.key !== ESCAPE_KEY$1) {
2556 return;
2557 }
2558 if (this._config.keyboard) {
2559 this.hide();
2560 return;
2561 }
2562 this._triggerBackdropTransition();
2563 });
2564 EventHandler.on(window, EVENT_RESIZE$1, () => {
2565 if (this._isShown && !this._isTransitioning) {
2566 this._adjustDialog();
2567 }
2568 });
2569 EventHandler.on(this._element, EVENT_MOUSEDOWN_DISMISS, event => {
2570 // a bad trick to segregate clicks that may start inside dialog but end outside, and avoid listen to scrollbar clicks
2571 EventHandler.one(this._element, EVENT_CLICK_DISMISS, event2 => {
2572 if (this._element !== event.target || this._element !== event2.target) {
2573 return;
2574 }
2575 if (this._config.backdrop === 'static') {
2576 this._triggerBackdropTransition();
2577 return;
2578 }
2579 if (this._config.backdrop) {
2580 this.hide();
2581 }
2582 });
2583 });
2584 }
2585 _hideModal() {
2586 this._element.style.display = 'none';
2587 this._element.setAttribute('aria-hidden', true);
2588 this._element.removeAttribute('aria-modal');
2589 this._element.removeAttribute('role');
2590 this._isTransitioning = false;
2591 this._backdrop.hide(() => {
2592 document.body.classList.remove(CLASS_NAME_OPEN);
2593 this._resetAdjustments();
2594 this._scrollBar.reset();
2595 EventHandler.trigger(this._element, EVENT_HIDDEN$4);
2596 });
2597 }
2598 _isAnimated() {
2599 return this._element.classList.contains(CLASS_NAME_FADE$3);
2600 }
2601 _triggerBackdropTransition() {
2602 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED$1);
2603 if (hideEvent.defaultPrevented) {
2604 return;
2605 }
2606 const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
2607 const initialOverflowY = this._element.style.overflowY;
2608 // return if the following background transition hasn't yet completed
2609 if (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) {
2610 return;
2611 }
2612 if (!isModalOverflowing) {
2613 this._element.style.overflowY = 'hidden';
2614 }
2615 this._element.classList.add(CLASS_NAME_STATIC);
2616 this._queueCallback(() => {
2617 this._element.classList.remove(CLASS_NAME_STATIC);
2618 this._queueCallback(() => {
2619 this._element.style.overflowY = initialOverflowY;
2620 }, this._dialog);
2621 }, this._dialog);
2622 this._element.focus();
2623 }
2624
2625 /**
2626 * The following methods are used to handle overflowing modals
2627 */
2628
2629 _adjustDialog() {
2630 const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
2631 const scrollbarWidth = this._scrollBar.getWidth();
2632 const isBodyOverflowing = scrollbarWidth > 0;
2633 if (isBodyOverflowing && !isModalOverflowing) {
2634 const property = isRTL() ? 'paddingLeft' : 'paddingRight';
2635 this._element.style[property] = `${scrollbarWidth}px`;
2636 }
2637 if (!isBodyOverflowing && isModalOverflowing) {
2638 const property = isRTL() ? 'paddingRight' : 'paddingLeft';
2639 this._element.style[property] = `${scrollbarWidth}px`;
2640 }
2641 }
2642 _resetAdjustments() {
2643 this._element.style.paddingLeft = '';
2644 this._element.style.paddingRight = '';
2645 }
2646
2647 // Static
2648 static jQueryInterface(config, relatedTarget) {
2649 return this.each(function () {
2650 const data = Modal.getOrCreateInstance(this, config);
2651 if (typeof config !== 'string') {
2652 return;
2653 }
2654 if (typeof data[config] === 'undefined') {
2655 throw new TypeError(`No method named "${config}"`);
2656 }
2657 data[config](relatedTarget);
2658 });
2659 }
2660 }
2661
2662 /**
2663 * Data API implementation
2664 */
2665
2666 EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) {
2667 const target = SelectorEngine.getElementFromSelector(this);
2668 if (['A', 'AREA'].includes(this.tagName)) {
2669 event.preventDefault();
2670 }
2671 EventHandler.one(target, EVENT_SHOW$4, showEvent => {
2672 if (showEvent.defaultPrevented) {
2673 // only register focus restorer if modal will actually get shown
2674 return;
2675 }
2676 EventHandler.one(target, EVENT_HIDDEN$4, () => {
2677 if (isVisible(this)) {
2678 this.focus();
2679 }
2680 });
2681 });
2682
2683 // avoid conflict when clicking modal toggler while another one is open
2684 const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1);
2685 if (alreadyOpen) {
2686 Modal.getInstance(alreadyOpen).hide();
2687 }
2688 const data = Modal.getOrCreateInstance(target);
2689 data.toggle(this);
2690 });
2691 enableDismissTrigger(Modal);
2692
2693 /**
2694 * jQuery
2695 */
2696
2697 defineJQueryPlugin(Modal);
2698
2699 /**
2700 * --------------------------------------------------------------------------
2701 * Bootstrap offcanvas.js
2702 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2703 * --------------------------------------------------------------------------
2704 */
2705
2706
2707 /**
2708 * Constants
2709 */
2710
2711 const NAME$6 = 'offcanvas';
2712 const DATA_KEY$3 = 'bs.offcanvas';
2713 const EVENT_KEY$3 = `.${DATA_KEY$3}`;
2714 const DATA_API_KEY$1 = '.data-api';
2715 const EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$3}${DATA_API_KEY$1}`;
2716 const ESCAPE_KEY = 'Escape';
2717 const CLASS_NAME_SHOW$3 = 'show';
2718 const CLASS_NAME_SHOWING$1 = 'showing';
2719 const CLASS_NAME_HIDING = 'hiding';
2720 const CLASS_NAME_BACKDROP = 'offcanvas-backdrop';
2721 const OPEN_SELECTOR = '.offcanvas.show';
2722 const EVENT_SHOW$3 = `show${EVENT_KEY$3}`;
2723 const EVENT_SHOWN$3 = `shown${EVENT_KEY$3}`;
2724 const EVENT_HIDE$3 = `hide${EVENT_KEY$3}`;
2725 const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$3}`;
2726 const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$3}`;
2727 const EVENT_RESIZE = `resize${EVENT_KEY$3}`;
2728 const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$3}${DATA_API_KEY$1}`;
2729 const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$3}`;
2730 const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]';
2731 const Default$5 = {
2732 backdrop: true,
2733 keyboard: true,
2734 scroll: false
2735 };
2736 const DefaultType$5 = {
2737 backdrop: '(boolean|string)',
2738 keyboard: 'boolean',
2739 scroll: 'boolean'
2740 };
2741
2742 /**
2743 * Class definition
2744 */
2745
2746 class Offcanvas extends BaseComponent {
2747 constructor(element, config) {
2748 super(element, config);
2749 this._isShown = false;
2750 this._backdrop = this._initializeBackDrop();
2751 this._focustrap = this._initializeFocusTrap();
2752 this._addEventListeners();
2753 }
2754
2755 // Getters
2756 static get Default() {
2757 return Default$5;
2758 }
2759 static get DefaultType() {
2760 return DefaultType$5;
2761 }
2762 static get NAME() {
2763 return NAME$6;
2764 }
2765
2766 // Public
2767 toggle(relatedTarget) {
2768 return this._isShown ? this.hide() : this.show(relatedTarget);
2769 }
2770 show(relatedTarget) {
2771 if (this._isShown) {
2772 return;
2773 }
2774 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {
2775 relatedTarget
2776 });
2777 if (showEvent.defaultPrevented) {
2778 return;
2779 }
2780 this._isShown = true;
2781 this._backdrop.show();
2782 if (!this._config.scroll) {
2783 new ScrollBarHelper().hide();
2784 }
2785 this._element.setAttribute('aria-modal', true);
2786 this._element.setAttribute('role', 'dialog');
2787 this._element.classList.add(CLASS_NAME_SHOWING$1);
2788 const completeCallBack = () => {
2789 if (!this._config.scroll || this._config.backdrop) {
2790 this._focustrap.activate();
2791 }
2792 this._element.classList.add(CLASS_NAME_SHOW$3);
2793 this._element.classList.remove(CLASS_NAME_SHOWING$1);
2794 EventHandler.trigger(this._element, EVENT_SHOWN$3, {
2795 relatedTarget
2796 });
2797 };
2798 this._queueCallback(completeCallBack, this._element, true);
2799 }
2800 hide() {
2801 if (!this._isShown) {
2802 return;
2803 }
2804 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3);
2805 if (hideEvent.defaultPrevented) {
2806 return;
2807 }
2808 this._focustrap.deactivate();
2809 this._element.blur();
2810 this._isShown = false;
2811 this._element.classList.add(CLASS_NAME_HIDING);
2812 this._backdrop.hide();
2813 const completeCallback = () => {
2814 this._element.classList.remove(CLASS_NAME_SHOW$3, CLASS_NAME_HIDING);
2815 this._element.removeAttribute('aria-modal');
2816 this._element.removeAttribute('role');
2817 if (!this._config.scroll) {
2818 new ScrollBarHelper().reset();
2819 }
2820 EventHandler.trigger(this._element, EVENT_HIDDEN$3);
2821 };
2822 this._queueCallback(completeCallback, this._element, true);
2823 }
2824 dispose() {
2825 this._backdrop.dispose();
2826 this._focustrap.deactivate();
2827 super.dispose();
2828 }
2829
2830 // Private
2831 _initializeBackDrop() {
2832 const clickCallback = () => {
2833 if (this._config.backdrop === 'static') {
2834 EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
2835 return;
2836 }
2837 this.hide();
2838 };
2839
2840 // 'static' option will be translated to true, and booleans will keep their value
2841 const isVisible = Boolean(this._config.backdrop);
2842 return new Backdrop({
2843 className: CLASS_NAME_BACKDROP,
2844 isVisible,
2845 isAnimated: true,
2846 rootElement: this._element.parentNode,
2847 clickCallback: isVisible ? clickCallback : null
2848 });
2849 }
2850 _initializeFocusTrap() {
2851 return new FocusTrap({
2852 trapElement: this._element
2853 });
2854 }
2855 _addEventListeners() {
2856 EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {
2857 if (event.key !== ESCAPE_KEY) {
2858 return;
2859 }
2860 if (this._config.keyboard) {
2861 this.hide();
2862 return;
2863 }
2864 EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
2865 });
2866 }
2867
2868 // Static
2869 static jQueryInterface(config) {
2870 return this.each(function () {
2871 const data = Offcanvas.getOrCreateInstance(this, config);
2872 if (typeof config !== 'string') {
2873 return;
2874 }
2875 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
2876 throw new TypeError(`No method named "${config}"`);
2877 }
2878 data[config](this);
2879 });
2880 }
2881 }
2882
2883 /**
2884 * Data API implementation
2885 */
2886
2887 EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) {
2888 const target = SelectorEngine.getElementFromSelector(this);
2889 if (['A', 'AREA'].includes(this.tagName)) {
2890 event.preventDefault();
2891 }
2892 if (isDisabled(this)) {
2893 return;
2894 }
2895 EventHandler.one(target, EVENT_HIDDEN$3, () => {
2896 // focus on trigger when it is closed
2897 if (isVisible(this)) {
2898 this.focus();
2899 }
2900 });
2901
2902 // avoid conflict when clicking a toggler of an offcanvas, while another is open
2903 const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);
2904 if (alreadyOpen && alreadyOpen !== target) {
2905 Offcanvas.getInstance(alreadyOpen).hide();
2906 }
2907 const data = Offcanvas.getOrCreateInstance(target);
2908 data.toggle(this);
2909 });
2910 EventHandler.on(window, EVENT_LOAD_DATA_API$2, () => {
2911 for (const selector of SelectorEngine.find(OPEN_SELECTOR)) {
2912 Offcanvas.getOrCreateInstance(selector).show();
2913 }
2914 });
2915 EventHandler.on(window, EVENT_RESIZE, () => {
2916 for (const element of SelectorEngine.find('[aria-modal][class*=show][class*=offcanvas-]')) {
2917 if (getComputedStyle(element).position !== 'fixed') {
2918 Offcanvas.getOrCreateInstance(element).hide();
2919 }
2920 }
2921 });
2922 enableDismissTrigger(Offcanvas);
2923
2924 /**
2925 * jQuery
2926 */
2927
2928 defineJQueryPlugin(Offcanvas);
2929
2930 /**
2931 * --------------------------------------------------------------------------
2932 * Bootstrap util/sanitizer.js
2933 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2934 * --------------------------------------------------------------------------
2935 */
2936
2937 // js-docs-start allow-list
2938 const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
2939 const DefaultAllowlist = {
2940 // Global attributes allowed on any supplied element below.
2941 '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
2942 a: ['target', 'href', 'title', 'rel'],
2943 area: [],
2944 b: [],
2945 br: [],
2946 col: [],
2947 code: [],
2948 dd: [],
2949 div: [],
2950 dl: [],
2951 dt: [],
2952 em: [],
2953 hr: [],
2954 h1: [],
2955 h2: [],
2956 h3: [],
2957 h4: [],
2958 h5: [],
2959 h6: [],
2960 i: [],
2961 img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],
2962 li: [],
2963 ol: [],
2964 p: [],
2965 pre: [],
2966 s: [],
2967 small: [],
2968 span: [],
2969 sub: [],
2970 sup: [],
2971 strong: [],
2972 u: [],
2973 ul: []
2974 };
2975 // js-docs-end allow-list
2976
2977 const uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']);
2978
2979 /**
2980 * A pattern that recognizes URLs that are safe wrt. XSS in URL navigation
2981 * contexts.
2982 *
2983 * Shout-out to Angular https://github.com/angular/angular/blob/15.2.8/packages/core/src/sanitization/url_sanitizer.ts#L38
2984 */
2985 // eslint-disable-next-line unicorn/better-regex
2986 const SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/i;
2987 const allowedAttribute = (attribute, allowedAttributeList) => {
2988 const attributeName = attribute.nodeName.toLowerCase();
2989 if (allowedAttributeList.includes(attributeName)) {
2990 if (uriAttributes.has(attributeName)) {
2991 return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue));
2992 }
2993 return true;
2994 }
2995
2996 // Check if a regular expression validates the attribute.
2997 return allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp).some(regex => regex.test(attributeName));
2998 };
2999 function sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) {
3000 if (!unsafeHtml.length) {
3001 return unsafeHtml;
3002 }
3003 if (sanitizeFunction && typeof sanitizeFunction === 'function') {
3004 return sanitizeFunction(unsafeHtml);
3005 }
3006 const domParser = new window.DOMParser();
3007 const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');
3008 const elements = [].concat(...createdDocument.body.querySelectorAll('*'));
3009 for (const element of elements) {
3010 const elementName = element.nodeName.toLowerCase();
3011 if (!Object.keys(allowList).includes(elementName)) {
3012 element.remove();
3013 continue;
3014 }
3015 const attributeList = [].concat(...element.attributes);
3016 const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []);
3017 for (const attribute of attributeList) {
3018 if (!allowedAttribute(attribute, allowedAttributes)) {
3019 element.removeAttribute(attribute.nodeName);
3020 }
3021 }
3022 }
3023 return createdDocument.body.innerHTML;
3024 }
3025
3026 /**
3027 * --------------------------------------------------------------------------
3028 * Bootstrap util/template-factory.js
3029 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
3030 * --------------------------------------------------------------------------
3031 */
3032
3033
3034 /**
3035 * Constants
3036 */
3037
3038 const NAME$5 = 'TemplateFactory';
3039 const Default$4 = {
3040 allowList: DefaultAllowlist,
3041 content: {},
3042 // { selector : text , selector2 : text2 , }
3043 extraClass: '',
3044 html: false,
3045 sanitize: true,
3046 sanitizeFn: null,
3047 template: '<div></div>'
3048 };
3049 const DefaultType$4 = {
3050 allowList: 'object',
3051 content: 'object',
3052 extraClass: '(string|function)',
3053 html: 'boolean',
3054 sanitize: 'boolean',
3055 sanitizeFn: '(null|function)',
3056 template: 'string'
3057 };
3058 const DefaultContentType = {
3059 entry: '(string|element|function|null)',
3060 selector: '(string|element)'
3061 };
3062
3063 /**
3064 * Class definition
3065 */
3066
3067 class TemplateFactory extends Config {
3068 constructor(config) {
3069 super();
3070 this._config = this._getConfig(config);
3071 }
3072
3073 // Getters
3074 static get Default() {
3075 return Default$4;
3076 }
3077 static get DefaultType() {
3078 return DefaultType$4;
3079 }
3080 static get NAME() {
3081 return NAME$5;
3082 }
3083
3084 // Public
3085 getContent() {
3086 return Object.values(this._config.content).map(config => this._resolvePossibleFunction(config)).filter(Boolean);
3087 }
3088 hasContent() {
3089 return this.getContent().length > 0;
3090 }
3091 changeContent(content) {
3092 this._checkContent(content);
3093 this._config.content = {
3094 ...this._config.content,
3095 ...content
3096 };
3097 return this;
3098 }
3099 toHtml() {
3100 const templateWrapper = document.createElement('div');
3101 templateWrapper.innerHTML = this._maybeSanitize(this._config.template);
3102 for (const [selector, text] of Object.entries(this._config.content)) {
3103 this._setContent(templateWrapper, text, selector);
3104 }
3105 const template = templateWrapper.children[0];
3106 const extraClass = this._resolvePossibleFunction(this._config.extraClass);
3107 if (extraClass) {
3108 template.classList.add(...extraClass.split(' '));
3109 }
3110 return template;
3111 }
3112
3113 // Private
3114 _typeCheckConfig(config) {
3115 super._typeCheckConfig(config);
3116 this._checkContent(config.content);
3117 }
3118 _checkContent(arg) {
3119 for (const [selector, content] of Object.entries(arg)) {
3120 super._typeCheckConfig({
3121 selector,
3122 entry: content
3123 }, DefaultContentType);
3124 }
3125 }
3126 _setContent(template, content, selector) {
3127 const templateElement = SelectorEngine.findOne(selector, template);
3128 if (!templateElement) {
3129 return;
3130 }
3131 content = this._resolvePossibleFunction(content);
3132 if (!content) {
3133 templateElement.remove();
3134 return;
3135 }
3136 if (isElement(content)) {
3137 this._putElementInTemplate(getElement(content), templateElement);
3138 return;
3139 }
3140 if (this._config.html) {
3141 templateElement.innerHTML = this._maybeSanitize(content);
3142 return;
3143 }
3144 templateElement.textContent = content;
3145 }
3146 _maybeSanitize(arg) {
3147 return this._config.sanitize ? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn) : arg;
3148 }
3149 _resolvePossibleFunction(arg) {
3150 return execute(arg, [this]);
3151 }
3152 _putElementInTemplate(element, templateElement) {
3153 if (this._config.html) {
3154 templateElement.innerHTML = '';
3155 templateElement.append(element);
3156 return;
3157 }
3158 templateElement.textContent = element.textContent;
3159 }
3160 }
3161
3162 /**
3163 * --------------------------------------------------------------------------
3164 * Bootstrap tooltip.js
3165 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
3166 * --------------------------------------------------------------------------
3167 */
3168
3169
3170 /**
3171 * Constants
3172 */
3173
3174 const NAME$4 = 'tooltip';
3175 const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']);
3176 const CLASS_NAME_FADE$2 = 'fade';
3177 const CLASS_NAME_MODAL = 'modal';
3178 const CLASS_NAME_SHOW$2 = 'show';
3179 const SELECTOR_TOOLTIP_INNER = '.tooltip-inner';
3180 const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`;
3181 const EVENT_MODAL_HIDE = 'hide.bs.modal';
3182 const TRIGGER_HOVER = 'hover';
3183 const TRIGGER_FOCUS = 'focus';
3184 const TRIGGER_CLICK = 'click';
3185 const TRIGGER_MANUAL = 'manual';
3186 const EVENT_HIDE$2 = 'hide';
3187 const EVENT_HIDDEN$2 = 'hidden';
3188 const EVENT_SHOW$2 = 'show';
3189 const EVENT_SHOWN$2 = 'shown';
3190 const EVENT_INSERTED = 'inserted';
3191 const EVENT_CLICK$1 = 'click';
3192 const EVENT_FOCUSIN$1 = 'focusin';
3193 const EVENT_FOCUSOUT$1 = 'focusout';
3194 const EVENT_MOUSEENTER = 'mouseenter';
3195 const EVENT_MOUSELEAVE = 'mouseleave';
3196 const AttachmentMap = {
3197 AUTO: 'auto',
3198 TOP: 'top',
3199 RIGHT: isRTL() ? 'left' : 'right',
3200 BOTTOM: 'bottom',
3201 LEFT: isRTL() ? 'right' : 'left'
3202 };
3203 const Default$3 = {
3204 allowList: DefaultAllowlist,
3205 animation: true,
3206 boundary: 'clippingParents',
3207 container: false,
3208 customClass: '',
3209 delay: 0,
3210 fallbackPlacements: ['top', 'right', 'bottom', 'left'],
3211 html: false,
3212 offset: [0, 6],
3213 placement: 'top',
3214 popperConfig: null,
3215 sanitize: true,
3216 sanitizeFn: null,
3217 selector: false,
3218 template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>',
3219 title: '',
3220 trigger: 'hover focus'
3221 };
3222 const DefaultType$3 = {
3223 allowList: 'object',
3224 animation: 'boolean',
3225 boundary: '(string|element)',
3226 container: '(string|element|boolean)',
3227 customClass: '(string|function)',
3228 delay: '(number|object)',
3229 fallbackPlacements: 'array',
3230 html: 'boolean',
3231 offset: '(array|string|function)',
3232 placement: '(string|function)',
3233 popperConfig: '(null|object|function)',
3234 sanitize: 'boolean',
3235 sanitizeFn: '(null|function)',
3236 selector: '(string|boolean)',
3237 template: 'string',
3238 title: '(string|element|function)',
3239 trigger: 'string'
3240 };
3241
3242 /**
3243 * Class definition
3244 */
3245
3246 class Tooltip extends BaseComponent {
3247 constructor(element, config) {
3248 if (typeof Popper__namespace === 'undefined') {
3249 throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)');
3250 }
3251 super(element, config);
3252
3253 // Private
3254 this._isEnabled = true;
3255 this._timeout = 0;
3256 this._isHovered = null;
3257 this._activeTrigger = {};
3258 this._popper = null;
3259 this._templateFactory = null;
3260 this._newContent = null;
3261
3262 // Protected
3263 this.tip = null;
3264 this._setListeners();
3265 if (!this._config.selector) {
3266 this._fixTitle();
3267 }
3268 }
3269
3270 // Getters
3271 static get Default() {
3272 return Default$3;
3273 }
3274 static get DefaultType() {
3275 return DefaultType$3;
3276 }
3277 static get NAME() {
3278 return NAME$4;
3279 }
3280
3281 // Public
3282 enable() {
3283 this._isEnabled = true;
3284 }
3285 disable() {
3286 this._isEnabled = false;
3287 }
3288 toggleEnabled() {
3289 this._isEnabled = !this._isEnabled;
3290 }
3291 toggle() {
3292 if (!this._isEnabled) {
3293 return;
3294 }
3295 this._activeTrigger.click = !this._activeTrigger.click;
3296 if (this._isShown()) {
3297 this._leave();
3298 return;
3299 }
3300 this._enter();
3301 }
3302 dispose() {
3303 clearTimeout(this._timeout);
3304 EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
3305 if (this._element.getAttribute('data-bs-original-title')) {
3306 this._element.setAttribute('title', this._element.getAttribute('data-bs-original-title'));
3307 }
3308 this._disposePopper();
3309 super.dispose();
3310 }
3311 show() {
3312 if (this._element.style.display === 'none') {
3313 throw new Error('Please use show on visible elements');
3314 }
3315 if (!(this._isWithContent() && this._isEnabled)) {
3316 return;
3317 }
3318 const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW$2));
3319 const shadowRoot = findShadowRoot(this._element);
3320 const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element);
3321 if (showEvent.defaultPrevented || !isInTheDom) {
3322 return;
3323 }
3324
3325 // TODO: v6 remove this or make it optional
3326 this._disposePopper();
3327 const tip = this._getTipElement();
3328 this._element.setAttribute('aria-describedby', tip.getAttribute('id'));
3329 const {
3330 container
3331 } = this._config;
3332 if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
3333 container.append(tip);
3334 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED));
3335 }
3336 this._popper = this._createPopper(tip);
3337 tip.classList.add(CLASS_NAME_SHOW$2);
3338
3339 // If this is a touch-enabled device we add extra
3340 // empty mouseover listeners to the body's immediate children;
3341 // only needed because of broken event delegation on iOS
3342 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
3343 if ('ontouchstart' in document.documentElement) {
3344 for (const element of [].concat(...document.body.children)) {
3345 EventHandler.on(element, 'mouseover', noop);
3346 }
3347 }
3348 const complete = () => {
3349 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOWN$2));
3350 if (this._isHovered === false) {
3351 this._leave();
3352 }
3353 this._isHovered = false;
3354 };
3355 this._queueCallback(complete, this.tip, this._isAnimated());
3356 }
3357 hide() {
3358 if (!this._isShown()) {
3359 return;
3360 }
3361 const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE$2));
3362 if (hideEvent.defaultPrevented) {
3363 return;
3364 }
3365 const tip = this._getTipElement();
3366 tip.classList.remove(CLASS_NAME_SHOW$2);
3367
3368 // If this is a touch-enabled device we remove the extra
3369 // empty mouseover listeners we added for iOS support
3370 if ('ontouchstart' in document.documentElement) {
3371 for (const element of [].concat(...document.body.children)) {
3372 EventHandler.off(element, 'mouseover', noop);
3373 }
3374 }
3375 this._activeTrigger[TRIGGER_CLICK] = false;
3376 this._activeTrigger[TRIGGER_FOCUS] = false;
3377 this._activeTrigger[TRIGGER_HOVER] = false;
3378 this._isHovered = null; // it is a trick to support manual triggering
3379
3380 const complete = () => {
3381 if (this._isWithActiveTrigger()) {
3382 return;
3383 }
3384 if (!this._isHovered) {
3385 this._disposePopper();
3386 }
3387 this._element.removeAttribute('aria-describedby');
3388 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDDEN$2));
3389 };
3390 this._queueCallback(complete, this.tip, this._isAnimated());
3391 }
3392 update() {
3393 if (this._popper) {
3394 this._popper.update();
3395 }
3396 }
3397
3398 // Protected
3399 _isWithContent() {
3400 return Boolean(this._getTitle());
3401 }
3402 _getTipElement() {
3403 if (!this.tip) {
3404 this.tip = this._createTipElement(this._newContent || this._getContentForTemplate());
3405 }
3406 return this.tip;
3407 }
3408 _createTipElement(content) {
3409 const tip = this._getTemplateFactory(content).toHtml();
3410
3411 // TODO: remove this check in v6
3412 if (!tip) {
3413 return null;
3414 }
3415 tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2);
3416 // TODO: v6 the following can be achieved with CSS only
3417 tip.classList.add(`bs-${this.constructor.NAME}-auto`);
3418 const tipId = getUID(this.constructor.NAME).toString();
3419 tip.setAttribute('id', tipId);
3420 if (this._isAnimated()) {
3421 tip.classList.add(CLASS_NAME_FADE$2);
3422 }
3423 return tip;
3424 }
3425 setContent(content) {
3426 this._newContent = content;
3427 if (this._isShown()) {
3428 this._disposePopper();
3429 this.show();
3430 }
3431 }
3432 _getTemplateFactory(content) {
3433 if (this._templateFactory) {
3434 this._templateFactory.changeContent(content);
3435 } else {
3436 this._templateFactory = new TemplateFactory({
3437 ...this._config,
3438 // the `content` var has to be after `this._config`
3439 // to override config.content in case of popover
3440 content,
3441 extraClass: this._resolvePossibleFunction(this._config.customClass)
3442 });
3443 }
3444 return this._templateFactory;
3445 }
3446 _getContentForTemplate() {
3447 return {
3448 [SELECTOR_TOOLTIP_INNER]: this._getTitle()
3449 };
3450 }
3451 _getTitle() {
3452 return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute('data-bs-original-title');
3453 }
3454
3455 // Private
3456 _initializeOnDelegatedTarget(event) {
3457 return this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig());
3458 }
3459 _isAnimated() {
3460 return this._config.animation || this.tip && this.tip.classList.contains(CLASS_NAME_FADE$2);
3461 }
3462 _isShown() {
3463 return this.tip && this.tip.classList.contains(CLASS_NAME_SHOW$2);
3464 }
3465 _createPopper(tip) {
3466 const placement = execute(this._config.placement, [this, tip, this._element]);
3467 const attachment = AttachmentMap[placement.toUpperCase()];
3468 return Popper__namespace.createPopper(this._element, tip, this._getPopperConfig(attachment));
3469 }
3470 _getOffset() {
3471 const {
3472 offset
3473 } = this._config;
3474 if (typeof offset === 'string') {
3475 return offset.split(',').map(value => Number.parseInt(value, 10));
3476 }
3477 if (typeof offset === 'function') {
3478 return popperData => offset(popperData, this._element);
3479 }
3480 return offset;
3481 }
3482 _resolvePossibleFunction(arg) {
3483 return execute(arg, [this._element]);
3484 }
3485 _getPopperConfig(attachment) {
3486 const defaultBsPopperConfig = {
3487 placement: attachment,
3488 modifiers: [{
3489 name: 'flip',
3490 options: {
3491 fallbackPlacements: this._config.fallbackPlacements
3492 }
3493 }, {
3494 name: 'offset',
3495 options: {
3496 offset: this._getOffset()
3497 }
3498 }, {
3499 name: 'preventOverflow',
3500 options: {
3501 boundary: this._config.boundary
3502 }
3503 }, {
3504 name: 'arrow',
3505 options: {
3506 element: `.${this.constructor.NAME}-arrow`
3507 }
3508 }, {
3509 name: 'preSetPlacement',
3510 enabled: true,
3511 phase: 'beforeMain',
3512 fn: data => {
3513 // Pre-set Popper's placement attribute in order to read the arrow sizes properly.
3514 // Otherwise, Popper mixes up the width and height dimensions since the initial arrow style is for top placement
3515 this._getTipElement().setAttribute('data-popper-placement', data.state.placement);
3516 }
3517 }]
3518 };
3519 return {
3520 ...defaultBsPopperConfig,
3521 ...execute(this._config.popperConfig, [defaultBsPopperConfig])
3522 };
3523 }
3524 _setListeners() {
3525 const triggers = this._config.trigger.split(' ');
3526 for (const trigger of triggers) {
3527 if (trigger === 'click') {
3528 EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK$1), this._config.selector, event => {
3529 const context = this._initializeOnDelegatedTarget(event);
3530 context.toggle();
3531 });
3532 } else if (trigger !== TRIGGER_MANUAL) {
3533 const eventIn = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSEENTER) : this.constructor.eventName(EVENT_FOCUSIN$1);
3534 const eventOut = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSELEAVE) : this.constructor.eventName(EVENT_FOCUSOUT$1);
3535 EventHandler.on(this._element, eventIn, this._config.selector, event => {
3536 const context = this._initializeOnDelegatedTarget(event);
3537 context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;
3538 context._enter();
3539 });
3540 EventHandler.on(this._element, eventOut, this._config.selector, event => {
3541 const context = this._initializeOnDelegatedTarget(event);
3542 context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget);
3543 context._leave();
3544 });
3545 }
3546 }
3547 this._hideModalHandler = () => {
3548 if (this._element) {
3549 this.hide();
3550 }
3551 };
3552 EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
3553 }
3554 _fixTitle() {
3555 const title = this._element.getAttribute('title');
3556 if (!title) {
3557 return;
3558 }
3559 if (!this._element.getAttribute('aria-label') && !this._element.textContent.trim()) {
3560 this._element.setAttribute('aria-label', title);
3561 }
3562 this._element.setAttribute('data-bs-original-title', title); // DO NOT USE IT. Is only for backwards compatibility
3563 this._element.removeAttribute('title');
3564 }
3565 _enter() {
3566 if (this._isShown() || this._isHovered) {
3567 this._isHovered = true;
3568 return;
3569 }
3570 this._isHovered = true;
3571 this._setTimeout(() => {
3572 if (this._isHovered) {
3573 this.show();
3574 }
3575 }, this._config.delay.show);
3576 }
3577 _leave() {
3578 if (this._isWithActiveTrigger()) {
3579 return;
3580 }
3581 this._isHovered = false;
3582 this._setTimeout(() => {
3583 if (!this._isHovered) {
3584 this.hide();
3585 }
3586 }, this._config.delay.hide);
3587 }
3588 _setTimeout(handler, timeout) {
3589 clearTimeout(this._timeout);
3590 this._timeout = setTimeout(handler, timeout);
3591 }
3592 _isWithActiveTrigger() {
3593 return Object.values(this._activeTrigger).includes(true);
3594 }
3595 _getConfig(config) {
3596 const dataAttributes = Manipulator.getDataAttributes(this._element);
3597 for (const dataAttribute of Object.keys(dataAttributes)) {
3598 if (DISALLOWED_ATTRIBUTES.has(dataAttribute)) {
3599 delete dataAttributes[dataAttribute];
3600 }
3601 }
3602 config = {
3603 ...dataAttributes,
3604 ...(typeof config === 'object' && config ? config : {})
3605 };
3606 config = this._mergeConfigObj(config);
3607 config = this._configAfterMerge(config);
3608 this._typeCheckConfig(config);
3609 return config;
3610 }
3611 _configAfterMerge(config) {
3612 config.container = config.container === false ? document.body : getElement(config.container);
3613 if (typeof config.delay === 'number') {
3614 config.delay = {
3615 show: config.delay,
3616 hide: config.delay
3617 };
3618 }
3619 if (typeof config.title === 'number') {
3620 config.title = config.title.toString();
3621 }
3622 if (typeof config.content === 'number') {
3623 config.content = config.content.toString();
3624 }
3625 return config;
3626 }
3627 _getDelegateConfig() {
3628 const config = {};
3629 for (const [key, value] of Object.entries(this._config)) {
3630 if (this.constructor.Default[key] !== value) {
3631 config[key] = value;
3632 }
3633 }
3634 config.selector = false;
3635 config.trigger = 'manual';
3636
3637 // In the future can be replaced with:
3638 // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])
3639 // `Object.fromEntries(keysWithDifferentValues)`
3640 return config;
3641 }
3642 _disposePopper() {
3643 if (this._popper) {
3644 this._popper.destroy();
3645 this._popper = null;
3646 }
3647 if (this.tip) {
3648 this.tip.remove();
3649 this.tip = null;
3650 }
3651 }
3652
3653 // Static
3654 static jQueryInterface(config) {
3655 return this.each(function () {
3656 const data = Tooltip.getOrCreateInstance(this, config);
3657 if (typeof config !== 'string') {
3658 return;
3659 }
3660 if (typeof data[config] === 'undefined') {
3661 throw new TypeError(`No method named "${config}"`);
3662 }
3663 data[config]();
3664 });
3665 }
3666 }
3667
3668 /**
3669 * jQuery
3670 */
3671
3672 defineJQueryPlugin(Tooltip);
3673
3674 /**
3675 * --------------------------------------------------------------------------
3676 * Bootstrap popover.js
3677 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
3678 * --------------------------------------------------------------------------
3679 */
3680
3681
3682 /**
3683 * Constants
3684 */
3685
3686 const NAME$3 = 'popover';
3687 const SELECTOR_TITLE = '.popover-header';
3688 const SELECTOR_CONTENT = '.popover-body';
3689 const Default$2 = {
3690 ...Tooltip.Default,
3691 content: '',
3692 offset: [0, 8],
3693 placement: 'right',
3694 template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>',
3695 trigger: 'click'
3696 };
3697 const DefaultType$2 = {
3698 ...Tooltip.DefaultType,
3699 content: '(null|string|element|function)'
3700 };
3701
3702 /**
3703 * Class definition
3704 */
3705
3706 class Popover extends Tooltip {
3707 // Getters
3708 static get Default() {
3709 return Default$2;
3710 }
3711 static get DefaultType() {
3712 return DefaultType$2;
3713 }
3714 static get NAME() {
3715 return NAME$3;
3716 }
3717
3718 // Overrides
3719 _isWithContent() {
3720 return this._getTitle() || this._getContent();
3721 }
3722
3723 // Private
3724 _getContentForTemplate() {
3725 return {
3726 [SELECTOR_TITLE]: this._getTitle(),
3727 [SELECTOR_CONTENT]: this._getContent()
3728 };
3729 }
3730 _getContent() {
3731 return this._resolvePossibleFunction(this._config.content);
3732 }
3733
3734 // Static
3735 static jQueryInterface(config) {
3736 return this.each(function () {
3737 const data = Popover.getOrCreateInstance(this, config);
3738 if (typeof config !== 'string') {
3739 return;
3740 }
3741 if (typeof data[config] === 'undefined') {
3742 throw new TypeError(`No method named "${config}"`);
3743 }
3744 data[config]();
3745 });
3746 }
3747 }
3748
3749 /**
3750 * jQuery
3751 */
3752
3753 defineJQueryPlugin(Popover);
3754
3755 /**
3756 * --------------------------------------------------------------------------
3757 * Bootstrap scrollspy.js
3758 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
3759 * --------------------------------------------------------------------------
3760 */
3761
3762
3763 /**
3764 * Constants
3765 */
3766
3767 const NAME$2 = 'scrollspy';
3768 const DATA_KEY$2 = 'bs.scrollspy';
3769 const EVENT_KEY$2 = `.${DATA_KEY$2}`;
3770 const DATA_API_KEY = '.data-api';
3771 const EVENT_ACTIVATE = `activate${EVENT_KEY$2}`;
3772 const EVENT_CLICK = `click${EVENT_KEY$2}`;
3773 const EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$2}${DATA_API_KEY}`;
3774 const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';
3775 const CLASS_NAME_ACTIVE$1 = 'active';
3776 const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]';
3777 const SELECTOR_TARGET_LINKS = '[href]';
3778 const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
3779 const SELECTOR_NAV_LINKS = '.nav-link';
3780 const SELECTOR_NAV_ITEMS = '.nav-item';
3781 const SELECTOR_LIST_ITEMS = '.list-group-item';
3782 const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`;
3783 const SELECTOR_DROPDOWN = '.dropdown';
3784 const SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle';
3785 const Default$1 = {
3786 offset: null,
3787 // TODO: v6 @deprecated, keep it for backwards compatibility reasons
3788 rootMargin: '0px 0px -25%',
3789 smoothScroll: false,
3790 target: null,
3791 threshold: [0.1, 0.5, 1]
3792 };
3793 const DefaultType$1 = {
3794 offset: '(number|null)',
3795 // TODO v6 @deprecated, keep it for backwards compatibility reasons
3796 rootMargin: 'string',
3797 smoothScroll: 'boolean',
3798 target: 'element',
3799 threshold: 'array'
3800 };
3801
3802 /**
3803 * Class definition
3804 */
3805
3806 class ScrollSpy extends BaseComponent {
3807 constructor(element, config) {
3808 super(element, config);
3809
3810 // this._element is the observablesContainer and config.target the menu links wrapper
3811 this._targetLinks = new Map();
3812 this._observableSections = new Map();
3813 this._rootElement = getComputedStyle(this._element).overflowY === 'visible' ? null : this._element;
3814 this._activeTarget = null;
3815 this._observer = null;
3816 this._previousScrollData = {
3817 visibleEntryTop: 0,
3818 parentScrollTop: 0
3819 };
3820 this.refresh(); // initialize
3821 }
3822
3823 // Getters
3824 static get Default() {
3825 return Default$1;
3826 }
3827 static get DefaultType() {
3828 return DefaultType$1;
3829 }
3830 static get NAME() {
3831 return NAME$2;
3832 }
3833
3834 // Public
3835 refresh() {
3836 this._initializeTargetsAndObservables();
3837 this._maybeEnableSmoothScroll();
3838 if (this._observer) {
3839 this._observer.disconnect();
3840 } else {
3841 this._observer = this._getNewObserver();
3842 }
3843 for (const section of this._observableSections.values()) {
3844 this._observer.observe(section);
3845 }
3846 }
3847 dispose() {
3848 this._observer.disconnect();
3849 super.dispose();
3850 }
3851
3852 // Private
3853 _configAfterMerge(config) {
3854 // TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case
3855 config.target = getElement(config.target) || document.body;
3856
3857 // TODO: v6 Only for backwards compatibility reasons. Use rootMargin only
3858 config.rootMargin = config.offset ? `${config.offset}px 0px -30%` : config.rootMargin;
3859 if (typeof config.threshold === 'string') {
3860 config.threshold = config.threshold.split(',').map(value => Number.parseFloat(value));
3861 }
3862 return config;
3863 }
3864 _maybeEnableSmoothScroll() {
3865 if (!this._config.smoothScroll) {
3866 return;
3867 }
3868
3869 // unregister any previous listeners
3870 EventHandler.off(this._config.target, EVENT_CLICK);
3871 EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, event => {
3872 const observableSection = this._observableSections.get(event.target.hash);
3873 if (observableSection) {
3874 event.preventDefault();
3875 const root = this._rootElement || window;
3876 const height = observableSection.offsetTop - this._element.offsetTop;
3877 if (root.scrollTo) {
3878 root.scrollTo({
3879 top: height,
3880 behavior: 'smooth'
3881 });
3882 return;
3883 }
3884
3885 // Chrome 60 doesn't support `scrollTo`
3886 root.scrollTop = height;
3887 }
3888 });
3889 }
3890 _getNewObserver() {
3891 const options = {
3892 root: this._rootElement,
3893 threshold: this._config.threshold,
3894 rootMargin: this._config.rootMargin
3895 };
3896 return new IntersectionObserver(entries => this._observerCallback(entries), options);
3897 }
3898
3899 // The logic of selection
3900 _observerCallback(entries) {
3901 const targetElement = entry => this._targetLinks.get(`#${entry.target.id}`);
3902 const activate = entry => {
3903 this._previousScrollData.visibleEntryTop = entry.target.offsetTop;
3904 this._process(targetElement(entry));
3905 };
3906 const parentScrollTop = (this._rootElement || document.documentElement).scrollTop;
3907 const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop;
3908 this._previousScrollData.parentScrollTop = parentScrollTop;
3909 for (const entry of entries) {
3910 if (!entry.isIntersecting) {
3911 this._activeTarget = null;
3912 this._clearActiveClass(targetElement(entry));
3913 continue;
3914 }
3915 const entryIsLowerThanPrevious = entry.target.offsetTop >= this._previousScrollData.visibleEntryTop;
3916 // if we are scrolling down, pick the bigger offsetTop
3917 if (userScrollsDown && entryIsLowerThanPrevious) {
3918 activate(entry);
3919 // if parent isn't scrolled, let's keep the first visible item, breaking the iteration
3920 if (!parentScrollTop) {
3921 return;
3922 }
3923 continue;
3924 }
3925
3926 // if we are scrolling up, pick the smallest offsetTop
3927 if (!userScrollsDown && !entryIsLowerThanPrevious) {
3928 activate(entry);
3929 }
3930 }
3931 }
3932 _initializeTargetsAndObservables() {
3933 this._targetLinks = new Map();
3934 this._observableSections = new Map();
3935 const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target);
3936 for (const anchor of targetLinks) {
3937 // ensure that the anchor has an id and is not disabled
3938 if (!anchor.hash || isDisabled(anchor)) {
3939 continue;
3940 }
3941 const observableSection = SelectorEngine.findOne(decodeURI(anchor.hash), this._element);
3942
3943 // ensure that the observableSection exists & is visible
3944 if (isVisible(observableSection)) {
3945 this._targetLinks.set(decodeURI(anchor.hash), anchor);
3946 this._observableSections.set(anchor.hash, observableSection);
3947 }
3948 }
3949 }
3950 _process(target) {
3951 if (this._activeTarget === target) {
3952 return;
3953 }
3954 this._clearActiveClass(this._config.target);
3955 this._activeTarget = target;
3956 target.classList.add(CLASS_NAME_ACTIVE$1);
3957 this._activateParents(target);
3958 EventHandler.trigger(this._element, EVENT_ACTIVATE, {
3959 relatedTarget: target
3960 });
3961 }
3962 _activateParents(target) {
3963 // Activate dropdown parents
3964 if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
3965 SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, target.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$1);
3966 return;
3967 }
3968 for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) {
3969 // Set triggered links parents as active
3970 // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
3971 for (const item of SelectorEngine.prev(listGroup, SELECTOR_LINK_ITEMS)) {
3972 item.classList.add(CLASS_NAME_ACTIVE$1);
3973 }
3974 }
3975 }
3976 _clearActiveClass(parent) {
3977 parent.classList.remove(CLASS_NAME_ACTIVE$1);
3978 const activeNodes = SelectorEngine.find(`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE$1}`, parent);
3979 for (const node of activeNodes) {
3980 node.classList.remove(CLASS_NAME_ACTIVE$1);
3981 }
3982 }
3983
3984 // Static
3985 static jQueryInterface(config) {
3986 return this.each(function () {
3987 const data = ScrollSpy.getOrCreateInstance(this, config);
3988 if (typeof config !== 'string') {
3989 return;
3990 }
3991 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
3992 throw new TypeError(`No method named "${config}"`);
3993 }
3994 data[config]();
3995 });
3996 }
3997 }
3998
3999 /**
4000 * Data API implementation
4001 */
4002
4003 EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => {
4004 for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) {
4005 ScrollSpy.getOrCreateInstance(spy);
4006 }
4007 });
4008
4009 /**
4010 * jQuery
4011 */
4012
4013 defineJQueryPlugin(ScrollSpy);
4014
4015 /**
4016 * --------------------------------------------------------------------------
4017 * Bootstrap tab.js
4018 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
4019 * --------------------------------------------------------------------------
4020 */
4021
4022
4023 /**
4024 * Constants
4025 */
4026
4027 const NAME$1 = 'tab';
4028 const DATA_KEY$1 = 'bs.tab';
4029 const EVENT_KEY$1 = `.${DATA_KEY$1}`;
4030 const EVENT_HIDE$1 = `hide${EVENT_KEY$1}`;
4031 const EVENT_HIDDEN$1 = `hidden${EVENT_KEY$1}`;
4032 const EVENT_SHOW$1 = `show${EVENT_KEY$1}`;
4033 const EVENT_SHOWN$1 = `shown${EVENT_KEY$1}`;
4034 const EVENT_CLICK_DATA_API = `click${EVENT_KEY$1}`;
4035 const EVENT_KEYDOWN = `keydown${EVENT_KEY$1}`;
4036 const EVENT_LOAD_DATA_API = `load${EVENT_KEY$1}`;
4037 const ARROW_LEFT_KEY = 'ArrowLeft';
4038 const ARROW_RIGHT_KEY = 'ArrowRight';
4039 const ARROW_UP_KEY = 'ArrowUp';
4040 const ARROW_DOWN_KEY = 'ArrowDown';
4041 const HOME_KEY = 'Home';
4042 const END_KEY = 'End';
4043 const CLASS_NAME_ACTIVE = 'active';
4044 const CLASS_NAME_FADE$1 = 'fade';
4045 const CLASS_NAME_SHOW$1 = 'show';
4046 const CLASS_DROPDOWN = 'dropdown';
4047 const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
4048 const SELECTOR_DROPDOWN_MENU = '.dropdown-menu';
4049 const NOT_SELECTOR_DROPDOWN_TOGGLE = `:not(${SELECTOR_DROPDOWN_TOGGLE})`;
4050 const SELECTOR_TAB_PANEL = '.list-group, .nav, [role="tablist"]';
4051 const SELECTOR_OUTER = '.nav-item, .list-group-item';
4052 const SELECTOR_INNER = `.nav-link${NOT_SELECTOR_DROPDOWN_TOGGLE}, .list-group-item${NOT_SELECTOR_DROPDOWN_TOGGLE}, [role="tab"]${NOT_SELECTOR_DROPDOWN_TOGGLE}`;
4053 const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]'; // TODO: could only be `tab` in v6
4054 const SELECTOR_INNER_ELEM = `${SELECTOR_INNER}, ${SELECTOR_DATA_TOGGLE}`;
4055 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"]`;
4056
4057 /**
4058 * Class definition
4059 */
4060
4061 class Tab extends BaseComponent {
4062 constructor(element) {
4063 super(element);
4064 this._parent = this._element.closest(SELECTOR_TAB_PANEL);
4065 if (!this._parent) {
4066 return;
4067 // TODO: should throw exception in v6
4068 // throw new TypeError(`${element.outerHTML} has not a valid parent ${SELECTOR_INNER_ELEM}`)
4069 }
4070
4071 // Set up initial aria attributes
4072 this._setInitialAttributes(this._parent, this._getChildren());
4073 EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event));
4074 }
4075
4076 // Getters
4077 static get NAME() {
4078 return NAME$1;
4079 }
4080
4081 // Public
4082 show() {
4083 // Shows this elem and deactivate the active sibling if exists
4084 const innerElem = this._element;
4085 if (this._elemIsActive(innerElem)) {
4086 return;
4087 }
4088
4089 // Search for active tab on same parent to deactivate it
4090 const active = this._getActiveElem();
4091 const hideEvent = active ? EventHandler.trigger(active, EVENT_HIDE$1, {
4092 relatedTarget: innerElem
4093 }) : null;
4094 const showEvent = EventHandler.trigger(innerElem, EVENT_SHOW$1, {
4095 relatedTarget: active
4096 });
4097 if (showEvent.defaultPrevented || hideEvent && hideEvent.defaultPrevented) {
4098 return;
4099 }
4100 this._deactivate(active, innerElem);
4101 this._activate(innerElem, active);
4102 }
4103
4104 // Private
4105 _activate(element, relatedElem) {
4106 if (!element) {
4107 return;
4108 }
4109 element.classList.add(CLASS_NAME_ACTIVE);
4110 this._activate(SelectorEngine.getElementFromSelector(element)); // Search and activate/show the proper section
4111
4112 const complete = () => {
4113 if (element.getAttribute('role') !== 'tab') {
4114 element.classList.add(CLASS_NAME_SHOW$1);
4115 return;
4116 }
4117 element.removeAttribute('tabindex');
4118 element.setAttribute('aria-selected', true);
4119 this._toggleDropDown(element, true);
4120 EventHandler.trigger(element, EVENT_SHOWN$1, {
4121 relatedTarget: relatedElem
4122 });
4123 };
4124 this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1));
4125 }
4126 _deactivate(element, relatedElem) {
4127 if (!element) {
4128 return;
4129 }
4130 element.classList.remove(CLASS_NAME_ACTIVE);
4131 element.blur();
4132 this._deactivate(SelectorEngine.getElementFromSelector(element)); // Search and deactivate the shown section too
4133
4134 const complete = () => {
4135 if (element.getAttribute('role') !== 'tab') {
4136 element.classList.remove(CLASS_NAME_SHOW$1);
4137 return;
4138 }
4139 element.setAttribute('aria-selected', false);
4140 element.setAttribute('tabindex', '-1');
4141 this._toggleDropDown(element, false);
4142 EventHandler.trigger(element, EVENT_HIDDEN$1, {
4143 relatedTarget: relatedElem
4144 });
4145 };
4146 this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1));
4147 }
4148 _keydown(event) {
4149 if (![ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY, HOME_KEY, END_KEY].includes(event.key)) {
4150 return;
4151 }
4152 event.stopPropagation(); // stopPropagation/preventDefault both added to support up/down keys without scrolling the page
4153 event.preventDefault();
4154 const children = this._getChildren().filter(element => !isDisabled(element));
4155 let nextActiveElement;
4156 if ([HOME_KEY, END_KEY].includes(event.key)) {
4157 nextActiveElement = children[event.key === HOME_KEY ? 0 : children.length - 1];
4158 } else {
4159 const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key);
4160 nextActiveElement = getNextActiveElement(children, event.target, isNext, true);
4161 }
4162 if (nextActiveElement) {
4163 nextActiveElement.focus({
4164 preventScroll: true
4165 });
4166 Tab.getOrCreateInstance(nextActiveElement).show();
4167 }
4168 }
4169 _getChildren() {
4170 // collection of inner elements
4171 return SelectorEngine.find(SELECTOR_INNER_ELEM, this._parent);
4172 }
4173 _getActiveElem() {
4174 return this._getChildren().find(child => this._elemIsActive(child)) || null;
4175 }
4176 _setInitialAttributes(parent, children) {
4177 this._setAttributeIfNotExists(parent, 'role', 'tablist');
4178 for (const child of children) {
4179 this._setInitialAttributesOnChild(child);
4180 }
4181 }
4182 _setInitialAttributesOnChild(child) {
4183 child = this._getInnerElement(child);
4184 const isActive = this._elemIsActive(child);
4185 const outerElem = this._getOuterElement(child);
4186 child.setAttribute('aria-selected', isActive);
4187 if (outerElem !== child) {
4188 this._setAttributeIfNotExists(outerElem, 'role', 'presentation');
4189 }
4190 if (!isActive) {
4191 child.setAttribute('tabindex', '-1');
4192 }
4193 this._setAttributeIfNotExists(child, 'role', 'tab');
4194
4195 // set attributes to the related panel too
4196 this._setInitialAttributesOnTargetPanel(child);
4197 }
4198 _setInitialAttributesOnTargetPanel(child) {
4199 const target = SelectorEngine.getElementFromSelector(child);
4200 if (!target) {
4201 return;
4202 }
4203 this._setAttributeIfNotExists(target, 'role', 'tabpanel');
4204 if (child.id) {
4205 this._setAttributeIfNotExists(target, 'aria-labelledby', `${child.id}`);
4206 }
4207 }
4208 _toggleDropDown(element, open) {
4209 const outerElem = this._getOuterElement(element);
4210 if (!outerElem.classList.contains(CLASS_DROPDOWN)) {
4211 return;
4212 }
4213 const toggle = (selector, className) => {
4214 const element = SelectorEngine.findOne(selector, outerElem);
4215 if (element) {
4216 element.classList.toggle(className, open);
4217 }
4218 };
4219 toggle(SELECTOR_DROPDOWN_TOGGLE, CLASS_NAME_ACTIVE);
4220 toggle(SELECTOR_DROPDOWN_MENU, CLASS_NAME_SHOW$1);
4221 outerElem.setAttribute('aria-expanded', open);
4222 }
4223 _setAttributeIfNotExists(element, attribute, value) {
4224 if (!element.hasAttribute(attribute)) {
4225 element.setAttribute(attribute, value);
4226 }
4227 }
4228 _elemIsActive(elem) {
4229 return elem.classList.contains(CLASS_NAME_ACTIVE);
4230 }
4231
4232 // Try to get the inner element (usually the .nav-link)
4233 _getInnerElement(elem) {
4234 return elem.matches(SELECTOR_INNER_ELEM) ? elem : SelectorEngine.findOne(SELECTOR_INNER_ELEM, elem);
4235 }
4236
4237 // Try to get the outer element (usually the .nav-item)
4238 _getOuterElement(elem) {
4239 return elem.closest(SELECTOR_OUTER) || elem;
4240 }
4241
4242 // Static
4243 static jQueryInterface(config) {
4244 return this.each(function () {
4245 const data = Tab.getOrCreateInstance(this);
4246 if (typeof config !== 'string') {
4247 return;
4248 }
4249 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
4250 throw new TypeError(`No method named "${config}"`);
4251 }
4252 data[config]();
4253 });
4254 }
4255 }
4256
4257 /**
4258 * Data API implementation
4259 */
4260
4261 EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
4262 if (['A', 'AREA'].includes(this.tagName)) {
4263 event.preventDefault();
4264 }
4265 if (isDisabled(this)) {
4266 return;
4267 }
4268 Tab.getOrCreateInstance(this).show();
4269 });
4270
4271 /**
4272 * Initialize on focus
4273 */
4274 EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
4275 for (const element of SelectorEngine.find(SELECTOR_DATA_TOGGLE_ACTIVE)) {
4276 Tab.getOrCreateInstance(element);
4277 }
4278 });
4279 /**
4280 * jQuery
4281 */
4282
4283 defineJQueryPlugin(Tab);
4284
4285 /**
4286 * --------------------------------------------------------------------------
4287 * Bootstrap toast.js
4288 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
4289 * --------------------------------------------------------------------------
4290 */
4291
4292
4293 /**
4294 * Constants
4295 */
4296
4297 const NAME = 'toast';
4298 const DATA_KEY = 'bs.toast';
4299 const EVENT_KEY = `.${DATA_KEY}`;
4300 const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`;
4301 const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`;
4302 const EVENT_FOCUSIN = `focusin${EVENT_KEY}`;
4303 const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`;
4304 const EVENT_HIDE = `hide${EVENT_KEY}`;
4305 const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
4306 const EVENT_SHOW = `show${EVENT_KEY}`;
4307 const EVENT_SHOWN = `shown${EVENT_KEY}`;
4308 const CLASS_NAME_FADE = 'fade';
4309 const CLASS_NAME_HIDE = 'hide'; // @deprecated - kept here only for backwards compatibility
4310 const CLASS_NAME_SHOW = 'show';
4311 const CLASS_NAME_SHOWING = 'showing';
4312 const DefaultType = {
4313 animation: 'boolean',
4314 autohide: 'boolean',
4315 delay: 'number'
4316 };
4317 const Default = {
4318 animation: true,
4319 autohide: true,
4320 delay: 5000
4321 };
4322
4323 /**
4324 * Class definition
4325 */
4326
4327 class Toast extends BaseComponent {
4328 constructor(element, config) {
4329 super(element, config);
4330 this._timeout = null;
4331 this._hasMouseInteraction = false;
4332 this._hasKeyboardInteraction = false;
4333 this._setListeners();
4334 }
4335
4336 // Getters
4337 static get Default() {
4338 return Default;
4339 }
4340 static get DefaultType() {
4341 return DefaultType;
4342 }
4343 static get NAME() {
4344 return NAME;
4345 }
4346
4347 // Public
4348 show() {
4349 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW);
4350 if (showEvent.defaultPrevented) {
4351 return;
4352 }
4353 this._clearTimeout();
4354 if (this._config.animation) {
4355 this._element.classList.add(CLASS_NAME_FADE);
4356 }
4357 const complete = () => {
4358 this._element.classList.remove(CLASS_NAME_SHOWING);
4359 EventHandler.trigger(this._element, EVENT_SHOWN);
4360 this._maybeScheduleHide();
4361 };
4362 this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated
4363 reflow(this._element);
4364 this._element.classList.add(CLASS_NAME_SHOW, CLASS_NAME_SHOWING);
4365 this._queueCallback(complete, this._element, this._config.animation);
4366 }
4367 hide() {
4368 if (!this.isShown()) {
4369 return;
4370 }
4371 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE);
4372 if (hideEvent.defaultPrevented) {
4373 return;
4374 }
4375 const complete = () => {
4376 this._element.classList.add(CLASS_NAME_HIDE); // @deprecated
4377 this._element.classList.remove(CLASS_NAME_SHOWING, CLASS_NAME_SHOW);
4378 EventHandler.trigger(this._element, EVENT_HIDDEN);
4379 };
4380 this._element.classList.add(CLASS_NAME_SHOWING);
4381 this._queueCallback(complete, this._element, this._config.animation);
4382 }
4383 dispose() {
4384 this._clearTimeout();
4385 if (this.isShown()) {
4386 this._element.classList.remove(CLASS_NAME_SHOW);
4387 }
4388 super.dispose();
4389 }
4390 isShown() {
4391 return this._element.classList.contains(CLASS_NAME_SHOW);
4392 }
4393
4394 // Private
4395
4396 _maybeScheduleHide() {
4397 if (!this._config.autohide) {
4398 return;
4399 }
4400 if (this._hasMouseInteraction || this._hasKeyboardInteraction) {
4401 return;
4402 }
4403 this._timeout = setTimeout(() => {
4404 this.hide();
4405 }, this._config.delay);
4406 }
4407 _onInteraction(event, isInteracting) {
4408 switch (event.type) {
4409 case 'mouseover':
4410 case 'mouseout':
4411 {
4412 this._hasMouseInteraction = isInteracting;
4413 break;
4414 }
4415 case 'focusin':
4416 case 'focusout':
4417 {
4418 this._hasKeyboardInteraction = isInteracting;
4419 break;
4420 }
4421 }
4422 if (isInteracting) {
4423 this._clearTimeout();
4424 return;
4425 }
4426 const nextElement = event.relatedTarget;
4427 if (this._element === nextElement || this._element.contains(nextElement)) {
4428 return;
4429 }
4430 this._maybeScheduleHide();
4431 }
4432 _setListeners() {
4433 EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true));
4434 EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false));
4435 EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true));
4436 EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false));
4437 }
4438 _clearTimeout() {
4439 clearTimeout(this._timeout);
4440 this._timeout = null;
4441 }
4442
4443 // Static
4444 static jQueryInterface(config) {
4445 return this.each(function () {
4446 const data = Toast.getOrCreateInstance(this, config);
4447 if (typeof config === 'string') {
4448 if (typeof data[config] === 'undefined') {
4449 throw new TypeError(`No method named "${config}"`);
4450 }
4451 data[config](this);
4452 }
4453 });
4454 }
4455 }
4456
4457 /**
4458 * Data API implementation
4459 */
4460
4461 enableDismissTrigger(Toast);
4462
4463 /**
4464 * jQuery
4465 */
4466
4467 defineJQueryPlugin(Toast);
4468
4469 /**
4470 * --------------------------------------------------------------------------
4471 * Bootstrap index.umd.js
4472 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
4473 * --------------------------------------------------------------------------
4474 */
4475
4476 const index_umd = {
4477 Alert,
4478 Button,
4479 Carousel,
4480 Collapse,
4481 Dropdown,
4482 Modal,
4483 Offcanvas,
4484 Popover,
4485 ScrollSpy,
4486 Tab,
4487 Toast,
4488 Tooltip
4489 };
4490
4491 return index_umd;
4492
4493}));
4494//# sourceMappingURL=bootstrap.js.map
Note: See TracBrowser for help on using the repository browser.