1/*! 2 * Understrap v1.1.0 (https://understrap.com) 3 * Copyright 2013-2023 The Understrap Authors (https://github.com/understrap/understrap/graphs/contributors) 4 * Licensed under GPL (http://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html) 5 */ 6(function (global, factory) { 7 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : 8 typeof define === 'function' && define.amd ? define(['exports'], factory) : 9 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.understrap = {})); 10})(this, (function (exports) { 'use strict'; 11 12 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; 13 14 function getDefaultExportFromCjs (x) { 15 return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; 16 } 17 18 function getAugmentedNamespace(n) { 19 if (n.__esModule) return n; 20 var a = Object.defineProperty({}, '__esModule', {value: true}); 21 Object.keys(n).forEach(function (k) { 22 var d = Object.getOwnPropertyDescriptor(n, k); 23 Object.defineProperty(a, k, d.get ? d : { 24 enumerable: true, 25 get: function () { 26 return n[k]; 27 } 28 }); 29 }); 30 return a; 31 } 32 33 var alert$1 = {exports: {}}; 34 35 var eventHandler = {exports: {}}; 36 37 /*! 38 * Bootstrap event-handler.js v5.1.3 (https://getbootstrap.com/) 39 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 40 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 41 */ 42 43 (function (module, exports) { 44 (function (global, factory) { 45 module.exports = factory() ; 46 })(commonjsGlobal, (function () { 47 /** 48 * -------------------------------------------------------------------------- 49 * Bootstrap (v5.1.3): util/index.js 50 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 51 * -------------------------------------------------------------------------- 52 */ 53 54 const getjQuery = () => { 55 const { 56 jQuery 57 } = window; 58 59 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 60 return jQuery; 61 } 62 63 return null; 64 }; 65 66 /** 67 * -------------------------------------------------------------------------- 68 * Bootstrap (v5.1.3): dom/event-handler.js 69 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 70 * -------------------------------------------------------------------------- 71 */ 72 /** 73 * ------------------------------------------------------------------------ 74 * Constants 75 * ------------------------------------------------------------------------ 76 */ 77 78 const namespaceRegex = /[^.]*(?=\..*)\.|.*/; 79 const stripNameRegex = /\..*/; 80 const stripUidRegex = /::\d+$/; 81 const eventRegistry = {}; // Events storage 82 83 let uidEvent = 1; 84 const customEvents = { 85 mouseenter: 'mouseover', 86 mouseleave: 'mouseout' 87 }; 88 const customEventsRegex = /^(mouseenter|mouseleave)/i; 89 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']); 90 /** 91 * ------------------------------------------------------------------------ 92 * Private methods 93 * ------------------------------------------------------------------------ 94 */ 95 96 function getUidEvent(element, uid) { 97 return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++; 98 } 99 100 function getEvent(element) { 101 const uid = getUidEvent(element); 102 element.uidEvent = uid; 103 eventRegistry[uid] = eventRegistry[uid] || {}; 104 return eventRegistry[uid]; 105 } 106 107 function bootstrapHandler(element, fn) { 108 return function handler(event) { 109 event.delegateTarget = element; 110 111 if (handler.oneOff) { 112 EventHandler.off(element, event.type, fn); 113 } 114 115 return fn.apply(element, [event]); 116 }; 117 } 118 119 function bootstrapDelegationHandler(element, selector, fn) { 120 return function handler(event) { 121 const domElements = element.querySelectorAll(selector); 122 123 for (let { 124 target 125 } = event; target && target !== this; target = target.parentNode) { 126 for (let i = domElements.length; i--;) { 127 if (domElements[i] === target) { 128 event.delegateTarget = target; 129 130 if (handler.oneOff) { 131 EventHandler.off(element, event.type, selector, fn); 132 } 133 134 return fn.apply(target, [event]); 135 } 136 } 137 } // To please ESLint 138 139 140 return null; 141 }; 142 } 143 144 function findHandler(events, handler, delegationSelector = null) { 145 const uidEventList = Object.keys(events); 146 147 for (let i = 0, len = uidEventList.length; i < len; i++) { 148 const event = events[uidEventList[i]]; 149 150 if (event.originalHandler === handler && event.delegationSelector === delegationSelector) { 151 return event; 152 } 153 } 154 155 return null; 156 } 157 158 function normalizeParams(originalTypeEvent, handler, delegationFn) { 159 const delegation = typeof handler === 'string'; 160 const originalHandler = delegation ? delegationFn : handler; 161 let typeEvent = getTypeEvent(originalTypeEvent); 162 const isNative = nativeEvents.has(typeEvent); 163 164 if (!isNative) { 165 typeEvent = originalTypeEvent; 166 } 167 168 return [delegation, originalHandler, typeEvent]; 169 } 170 171 function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) { 172 if (typeof originalTypeEvent !== 'string' || !element) { 173 return; 174 } 175 176 if (!handler) { 177 handler = delegationFn; 178 delegationFn = null; 179 } // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position 180 // this prevents the handler from being dispatched the same way as mouseover or mouseout does 181 182 183 if (customEventsRegex.test(originalTypeEvent)) { 184 const wrapFn = fn => { 185 return function (event) { 186 if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
vendor: 4,172 bytes, lines 187-304
187 return fn.call(this, event); 188 } 189 }; 190 }; 191 192 if (delegationFn) { 193 delegationFn = wrapFn(delegationFn); 194 } else { 195 handler = wrapFn(handler); 196 } 197 } 198 199 const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn); 200 const events = getEvent(element); 201 const handlers = events[typeEvent] || (events[typeEvent] = {}); 202 const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null); 203 204 if (previousFn) { 205 previousFn.oneOff = previousFn.oneOff && oneOff; 206 return; 207 } 208 209 const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, '')); 210 const fn = delegation ? bootstrapDelegationHandler(element, handler, delegationFn) : bootstrapHandler(element, handler); 211 fn.delegationSelector = delegation ? handler : null; 212 fn.originalHandler = originalHandler; 213 fn.oneOff = oneOff; 214 fn.uidEvent = uid; 215 handlers[uid] = fn; 216 element.addEventListener(typeEvent, fn, delegation); 217 } 218 219 function removeHandler(element, events, typeEvent, handler, delegationSelector) { 220 const fn = findHandler(events[typeEvent], handler, delegationSelector); 221 222 if (!fn) { 223 return; 224 } 225 226 element.removeEventListener(typeEvent, fn, Boolean(delegationSelector)); 227 delete events[typeEvent][fn.uidEvent]; 228 } 229 230 function removeNamespacedHandlers(element, events, typeEvent, namespace) { 231 const storeElementEvent = events[typeEvent] || {}; 232 Object.keys(storeElementEvent).forEach(handlerKey => { 233 if (handlerKey.includes(namespace)) { 234 const event = storeElementEvent[handlerKey]; 235 removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector); 236 } 237 }); 238 } 239 240 function getTypeEvent(event) { 241 // allow to get the native events from namespaced events ('click.bs.button' --> 'click') 242 event = event.replace(stripNameRegex, ''); 243 return customEvents[event] || event; 244 } 245 246 const EventHandler = { 247 on(element, event, handler, delegationFn) { 248 addHandler(element, event, handler, delegationFn, false); 249 }, 250 251 one(element, event, handler, delegationFn) { 252 addHandler(element, event, handler, delegationFn, true); 253 }, 254 255 off(element, originalTypeEvent, handler, delegationFn) { 256 if (typeof originalTypeEvent !== 'string' || !element) { 257 return; 258 } 259 260 const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn); 261 const inNamespace = typeEvent !== originalTypeEvent; 262 const events = getEvent(element); 263 const isNamespace = originalTypeEvent.startsWith('.'); 264 265 if (typeof originalHandler !== 'undefined') { 266 // Simplest case: handler is passed, remove that listener ONLY. 267 if (!events || !events[typeEvent]) { 268 return; 269 } 270 271 removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null); 272 return; 273 } 274 275 if (isNamespace) { 276 Object.keys(events).forEach(elementEvent => { 277 removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1)); 278 }); 279 } 280 281 const storeElementEvent = events[typeEvent] || {}; 282 Object.keys(storeElementEvent).forEach(keyHandlers => { 283 const handlerKey = keyHandlers.replace(stripUidRegex, ''); 284 285 if (!inNamespace || originalTypeEvent.includes(handlerKey)) { 286 const event = storeElementEvent[keyHandlers]; 287 removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector); 288 } 289 }); 290 }, 291 292 trigger(element, event, args) { 293 if (typeof event !== 'string' || !element) { 294 return null; 295 } 296 297 const $ = getjQuery(); 298 const typeEvent = getTypeEvent(event); 299 const inNamespace = event !== typeEvent; 300 const isNative = nativeEvents.has(typeEvent); 301 let jQueryEvent; 302 let bubbles = true; 303 let nativeDispatch = true; 304 let defaultPrevented = false;
305 let evt = null; 306 307 if (inNamespace && $) { 308 jQueryEvent = $.Event(event, args); 309 $(element).trigger(jQueryEvent); 310 bubbles = !jQueryEvent.isPropagationStopped(); 311 nativeDispatch = !jQueryEvent.isImmediatePropagationStopped(); 312 defaultPrevented = jQueryEvent.isDefaultPrevented(); 313 } 314 315 if (isNative) { 316 evt = document.createEvent('HTMLEvents'); 317 evt.initEvent(typeEvent, bubbles, true); 318 } else { 319 evt = new CustomEvent(event, { 320 bubbles, 321 cancelable: true 322 }); 323 } // merge custom information in our event 324 325 326 if (typeof args !== 'undefined') { 327 Object.keys(args).forEach(key => { 328 Object.defineProperty(evt, key, { 329 get() { 330 return args[key]; 331 } 332 333 }); 334 }); 335 } 336 337 if (defaultPrevented) { 338 evt.preventDefault(); 339 } 340 341 if (nativeDispatch) { 342 element.dispatchEvent(evt); 343 } 344 345 if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') { 346 jQueryEvent.preventDefault(); 347 } 348 349 return evt; 350 } 351 352 }; 353 354 return EventHandler; 355 356 })); 357 358 }(eventHandler)); 359 360 var baseComponent = {exports: {}}; 361 362 var data = {exports: {}}; 363 364 /*! 365 * Bootstrap data.js v5.1.3 (https://getbootstrap.com/) 366 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 367 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 368 */ 369 370 (function (module, exports) { 371 (function (global, factory) { 372 module.exports = factory() ; 373 })(commonjsGlobal, (function () { 374 /** 375 * -------------------------------------------------------------------------- 376 * Bootstrap (v5.1.3): dom/data.js 377 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 378 * -------------------------------------------------------------------------- 379 */ 380 381 /** 382 * ------------------------------------------------------------------------ 383 * Constants 384 * ------------------------------------------------------------------------ 385 */ 386 const elementMap = new Map(); 387 const data = { 388 set(element, key, instance) { 389 if (!elementMap.has(element)) { 390 elementMap.set(element, new Map()); 391 } 392 393 const instanceMap = elementMap.get(element); // make it clear we only want one instance per element 394 // can be removed later when multiple key/instances are fine to be used 395 396 if (!instanceMap.has(key) && instanceMap.size !== 0) { 397 // eslint-disable-next-line no-console 398 console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`); 399 return; 400 } 401 402 instanceMap.set(key, instance); 403 }, 404 405 get(element, key) { 406 if (elementMap.has(element)) { 407 return elementMap.get(element).get(key) || null; 408 } 409 410 return null; 411 }, 412 413 remove(element, key) { 414 if (!elementMap.has(element)) { 415 return; 416 } 417 418 const instanceMap = elementMap.get(element); 419 instanceMap.delete(key); // free up element references if there are no instances left for an element 420 421 if (instanceMap.size === 0) { 422 elementMap.delete(element); 423 } 424 } 425 426 }; 427 428 return data; 429 430 })); 431 432 }(data)); 433 434 /*! 435 * Bootstrap base-component.js v5.1.3 (https://getbootstrap.com/) 436 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 437 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 438 */ 439 440 (function (module, exports) { 441 (function (global, factory) { 442 module.exports = factory(data.exports, eventHandler.exports) ; 443 })(commonjsGlobal, (function (Data, EventHandler) { 444 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 445 446 const Data__default = /*#__PURE__*/_interopDefaultLegacy(Data); 447 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 448 449 /** 450 * -------------------------------------------------------------------------- 451 * Bootstrap (v5.1.3): util/index.js 452 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 453 * -------------------------------------------------------------------------- 454 */ 455 const MILLISECONDS_MULTIPLIER = 1000; 456 const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp) 457 458 const getTransitionDurationFromElement = element => { 459 if (!element) { 460 return 0; 461 } // Get transition-duration of the element 462 463 464 let { 465 transitionDuration, 466 transitionDelay 467 } = window.getComputedStyle(element); 468 const floatTransitionDuration = Number.parseFloat(transitionDuration); 469 const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found 470 471 if (!floatTransitionDuration && !floatTransitionDelay) { 472 return 0; 473 } // If multiple durations are defined, take the first 474 475 476 transitionDuration = transitionDuration.split(',')[0]; 477 transitionDelay = transitionDelay.split(',')[0]; 478 return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; 479 }; 480 481 const triggerTransitionEnd = element => { 482 element.dispatchEvent(new Event(TRANSITION_END)); 483 }; 484 485 const isElement = obj => { 486 if (!obj || typeof obj !== 'object') { 487 return false;
488 } 489 490 if (typeof obj.jquery !== 'undefined') { 491 obj = obj[0]; 492 } 493 494 return typeof obj.nodeType !== 'undefined'; 495 }; 496 497 const getElement = obj => { 498 if (isElement(obj)) { 499 // it's a jQuery object or a node element 500 return obj.jquery ? obj[0] : obj; 501 } 502 503 if (typeof obj === 'string' && obj.length > 0) { 504 return document.querySelector(obj); 505 } 506 507 return null; 508 }; 509 510 const execute = callback => { 511 if (typeof callback === 'function') { 512 callback(); 513 } 514 }; 515 516 const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => { 517 if (!waitForTransition) { 518 execute(callback); 519 return; 520 } 521 522 const durationPadding = 5; 523 const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding; 524 let called = false; 525 526 const handler = ({ 527 target 528 }) => { 529 if (target !== transitionElement) { 530 return; 531 } 532 533 called = true; 534 transitionElement.removeEventListener(TRANSITION_END, handler); 535 execute(callback); 536 }; 537 538 transitionElement.addEventListener(TRANSITION_END, handler); 539 setTimeout(() => { 540 if (!called) { 541 triggerTransitionEnd(transitionElement); 542 } 543 }, emulatedDuration); 544 }; 545 546 /** 547 * -------------------------------------------------------------------------- 548 * Bootstrap (v5.1.3): base-component.js 549 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 550 * -------------------------------------------------------------------------- 551 */ 552 /** 553 * ------------------------------------------------------------------------ 554 * Constants 555 * ------------------------------------------------------------------------ 556 */ 557 558 const VERSION = '5.1.3'; 559 560 class BaseComponent { 561 constructor(element) { 562 element = getElement(element); 563 564 if (!element) { 565 return; 566 } 567 568 this._element = element; 569 Data__default.default.set(this._element, this.constructor.DATA_KEY, this); 570 } 571 572 dispose() { 573 Data__default.default.remove(this._element, this.constructor.DATA_KEY); 574 EventHandler__default.default.off(this._element, this.constructor.EVENT_KEY); 575 Object.getOwnPropertyNames(this).forEach(propertyName => { 576 this[propertyName] = null; 577 }); 578 } 579 580 _queueCallback(callback, element, isAnimated = true) { 581 executeAfterTransition(callback, element, isAnimated); 582 } 583 /** Static */ 584 585 586 static getInstance(element) { 587 return Data__default.default.get(getElement(element), this.DATA_KEY); 588 } 589 590 static getOrCreateInstance(element, config = {}) { 591 return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null); 592 } 593 594 static get VERSION() { 595 return VERSION; 596 } 597 598 static get NAME() { 599 throw new Error('You have to implement the static method "NAME", for each component!'); 600 } 601 602 static get DATA_KEY() { 603 return `bs.${this.NAME}`; 604 } 605 606 static get EVENT_KEY() { 607 return `.${this.DATA_KEY}`; 608 } 609 610 } 611 612 return BaseComponent; 613 614 })); 615 616 }(baseComponent)); 617 618 /*! 619 * Bootstrap alert.js v5.1.3 (https://getbootstrap.com/) 620 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 621 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 622 */ 623 624 (function (module, exports) { 625 (function (global, factory) { 626 module.exports = factory(eventHandler.exports, baseComponent.exports) ; 627 })(commonjsGlobal, (function (EventHandler, BaseComponent) { 628 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 629 630 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 631 const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); 632 633 /** 634 * -------------------------------------------------------------------------- 635 * Bootstrap (v5.1.3): util/index.js 636 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 637 * -------------------------------------------------------------------------- 638 */ 639 640 const getSelector = element => { 641 let selector = element.getAttribute('data-bs-target'); 642 643 if (!selector || selector === '#') { 644 let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes, 645 // so everything starting with `#` or `.`. If a "real" URL is used as the selector, 646 // `document.querySelector` will rightfully complain it is invali
646d. 647 // See https://github.com/twbs/bootstrap/issues/32273 648 649 if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) { 650 return null; 651 } // Just in case some CMS puts out a full URL with the anchor appended 652 653 654 if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) { 655 hrefAttr = `#${hrefAttr.split('#')[1]}`; 656 } 657 658 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null; 659 } 660 661 return selector; 662 }; 663 664 const getElementFromSelector = element => { 665 const selector = getSelector(element); 666 return selector ? document.querySelector(selector) : null; 667 }; 668 669 const isDisabled = element => { 670 if (!element || element.nodeType !== Node.ELEMENT_NODE) { 671 return true; 672 } 673 674 if (element.classList.contains('disabled')) { 675 return true; 676 } 677 678 if (typeof element.disabled !== 'undefined') { 679 return element.disabled; 680 } 681 682 return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'; 683 }; 684 685 const getjQuery = () => { 686 const { 687 jQuery 688 } = window; 689 690 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 691 return jQuery; 692 } 693 694 return null; 695 }; 696 697 const DOMContentLoadedCallbacks = []; 698 699 const onDOMContentLoaded = callback => { 700 if (document.readyState === 'loading') { 701 // add listener on the first call when the document is in loading state 702 if (!DOMContentLoadedCallbacks.length) { 703 document.addEventListener('DOMContentLoaded', () => { 704 DOMContentLoadedCallbacks.forEach(callback => callback()); 705 }); 706 } 707 708 DOMContentLoadedCallbacks.push(callback); 709 } else { 710 callback(); 711 } 712 }; 713 714 const defineJQueryPlugin = plugin => { 715 onDOMContentLoaded(() => { 716 const $ = getjQuery(); 717 /* istanbul ignore if */ 718 719 if ($) { 720 const name = plugin.NAME; 721 const JQUERY_NO_CONFLICT = $.fn[name]; 722 $.fn[name] = plugin.jQueryInterface; 723 $.fn[name].Constructor = plugin; 724 725 $.fn[name].noConflict = () => { 726 $.fn[name] = JQUERY_NO_CONFLICT; 727 return plugin.jQueryInterface; 728 }; 729 } 730 }); 731 }; 732 733 /** 734 * -------------------------------------------------------------------------- 735 * Bootstrap (v5.1.3): util/component-functions.js 736 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 737 * -------------------------------------------------------------------------- 738 */ 739 740 const enableDismissTrigger = (component, method = 'hide') => { 741 const clickEvent = `click.dismiss${component.EVENT_KEY}`; 742 const name = component.NAME; 743 EventHandler__default.default.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) { 744 if (['A', 'AREA'].includes(this.tagName)) { 745 event.preventDefault(); 746 } 747 748 if (isDisabled(this)) { 749 return; 750 } 751 752 const target = getElementFromSelector(this) || this.closest(`.${name}`); 753 const instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method 754 755 instance[method](); 756 }); 757 }; 758 759 /** 760 * -------------------------------------------------------------------------- 761 * Bootstrap (v5.1.3): alert.js 762 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 763 * -------------------------------------------------------------------------- 764 */ 765 /** 766 * ------------------------------------------------------------------------ 767 * Constants 768 * ------------------------------------------------------------------------ 769 */ 770 771 const NAME = 'alert'; 772 const DATA_KEY = 'bs.alert'; 773 const EVENT_KEY = `.${DATA_KEY}`; 774 const EVENT_CLOSE = `close${EVENT_KEY}`; 775 const EVENT_CLOSED = `closed${EVENT_KEY}`; 776 const CLASS_NAME_FADE = 'fade'; 777 const CLASS_NAME_SHOW = 'show'; 778 /** 779 * ------------------------------------------------------------------------ 780 * Class Definition 781 * ------------------------------------------------------------------------ 782 */ 783 784 class Alert extends BaseComponent__default.default { 785 // Getters 786 static get NAME() { 787 return NAME; 788 } // Public 789 790 791 close() { 792 const closeEvent = EventHandler__default.default.trigger(this._element, EVENT_CLOSE); 793 794 if (closeEvent.defaultPrevented) { 795 return; 796 } 797 798 this._element.classList.remove(CLASS_NAME_SHOW); 799 800 const isAnimated = this._element.classList.contains(CLASS_NAME_FADE); 801 802 this._queueCallback(() => this._destroyElement(), this._element, isAnimated); 803 } // Private 804 805 806 _destroyElement() { 807 this._element.remove(); 808 809 EventHandler__default.default.trigger(this._element, EVENT_CLOSED); 810 this.dispose(); 811 } // Static 812 813 814 static jQueryInterface(config) { 815 return this.each(function () { 816 const data = Alert.getOrCreateInstance(this); 817 818 if (typeof config !== 'string') { 819 return; 820 } 821 822 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
823 throw new TypeError(`No method named "${config}"`); 824 } 825 826 data[config](this); 827 }); 828 } 829 830 } 831 /** 832 * ------------------------------------------------------------------------ 833 * Data Api implementation 834 * ------------------------------------------------------------------------ 835 */ 836 837 838 enableDismissTrigger(Alert, 'close'); 839 /** 840 * ------------------------------------------------------------------------ 841 * jQuery 842 * ------------------------------------------------------------------------ 843 * add .Alert to jQuery only if jQuery is present 844 */ 845 846 defineJQueryPlugin(Alert); 847 848 return Alert; 849 850 })); 851 852 }(alert$1)); 853 854 var alert = alert$1.exports; 855 856 var button$1 = {exports: {}}; 857 858 /*! 859 * Bootstrap button.js v5.1.3 (https://getbootstrap.com/) 860 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 861 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 862 */ 863 864 (function (module, exports) { 865 (function (global, factory) { 866 module.exports = factory(eventHandler.exports, baseComponent.exports) ; 867 })(commonjsGlobal, (function (EventHandler, BaseComponent) { 868 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 869 870 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 871 const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); 872 873 /** 874 * -------------------------------------------------------------------------- 875 * Bootstrap (v5.1.3): util/index.js 876 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 877 * -------------------------------------------------------------------------- 878 */ 879 880 const getjQuery = () => { 881 const { 882 jQuery 883 } = window; 884 885 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 886 return jQuery; 887 } 888 889 return null; 890 }; 891 892 const DOMContentLoadedCallbacks = []; 893 894 const onDOMContentLoaded = callback => { 895 if (document.readyState === 'loading') { 896 // add listener on the first call when the document is in loading state 897 if (!DOMContentLoadedCallbacks.length) { 898 document.addEventListener('DOMContentLoaded', () => { 899 DOMContentLoadedCallbacks.forEach(callback => callback()); 900 }); 901 } 902 903 DOMContentLoadedCallbacks.push(callback); 904 } else { 905 callback(); 906 } 907 }; 908 909 const defineJQueryPlugin = plugin => { 910 onDOMContentLoaded(() => { 911 const $ = getjQuery(); 912 /* istanbul ignore if */ 913 914 if ($) { 915 const name = plugin.NAME; 916 const JQUERY_NO_CONFLICT = $.fn[name]; 917 $.fn[name] = plugin.jQueryInterface; 918 $.fn[name].Constructor = plugin; 919 920 $.fn[name].noConflict = () => { 921 $.fn[name] = JQUERY_NO_CONFLICT; 922 return plugin.jQueryInterface; 923 }; 924 } 925 }); 926 }; 927 928 /** 929 * -------------------------------------------------------------------------- 930 * Bootstrap (v5.1.3): button.js 931 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 932 * -------------------------------------------------------------------------- 933 */ 934 /** 935 * ------------------------------------------------------------------------ 936 * Constants 937 * ------------------------------------------------------------------------ 938 */ 939 940 const NAME = 'button'; 941 const DATA_KEY = 'bs.button'; 942 const EVENT_KEY = `.${DATA_KEY}`; 943 const DATA_API_KEY = '.data-api'; 944 const CLASS_NAME_ACTIVE = 'active'; 945 const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="button"]'; 946 const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`; 947 /** 948 * ------------------------------------------------------------------------ 949 * Class Definition 950 * ------------------------------------------------------------------------ 951 */ 952 953 class Button extends BaseComponent__default.default { 954 // Getters 955 static get NAME() { 956 return NAME; 957 } // Public 958 959 960 toggle() { 961 // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle(
961)` method 962 this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE)); 963 } // Static 964 965 966 static jQueryInterface(config) { 967 return this.each(function () { 968 const data = Button.getOrCreateInstance(this); 969 970 if (config === 'toggle') { 971 data[config](); 972 } 973 }); 974 } 975 976 } 977 /** 978 * ------------------------------------------------------------------------ 979 * Data Api implementation 980 * ------------------------------------------------------------------------ 981 */ 982 983 984 EventHandler__default.default.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, event => { 985 event.preventDefault(); 986 const button = event.target.closest(SELECTOR_DATA_TOGGLE); 987 const data = Button.getOrCreateInstance(button); 988 data.toggle(); 989 }); 990 /** 991 * ------------------------------------------------------------------------ 992 * jQuery 993 * ------------------------------------------------------------------------ 994 * add .Button to jQuery only if jQuery is present 995 */ 996 997 defineJQueryPlugin(Button); 998 999 return Button; 1000 1001 })); 1002 1003 }(button$1)); 1004 1005 var button = button$1.exports; 1006 1007 var carousel$1 = {exports: {}}; 1008 1009 var manipulator = {exports: {}}; 1010 1011 /*! 1012 * Bootstrap manipulator.js v5.1.3 (https://getbootstrap.com/) 1013 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 1014 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 1015 */ 1016 1017 (function (module, exports) { 1018 (function (global, factory) { 1019 module.exports = factory() ; 1020 })(commonjsGlobal, (function () { 1021 /** 1022 * -------------------------------------------------------------------------- 1023 * Bootstrap (v5.1.3): dom/manipulator.js 1024 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 1025 * -------------------------------------------------------------------------- 1026 */ 1027 function normalizeData(val) { 1028 if (val === 'true') { 1029 return true; 1030 } 1031 1032 if (val === 'false') { 1033 return false; 1034 } 1035 1036 if (val === Number(val).toString()) { 1037 return Number(val); 1038 } 1039 1040 if (val === '' || val === 'null') { 1041 return null; 1042 } 1043 1044 return val; 1045 } 1046 1047 function normalizeDataKey(key) { 1048 return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`); 1049 } 1050 1051 const Manipulator = { 1052 setDataAttribute(element, key, value) { 1053 element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value); 1054 }, 1055 1056 removeDataAttribute(element, key) { 1057 element.removeAttribute(`data-bs-${normalizeDataKey(key)}`); 1058 }, 1059 1060 getDataAttributes(element) { 1061 if (!element) { 1062 return {}; 1063 } 1064 1065 const attributes = {}; 1066 Object.keys(element.dataset).filter(key => key.startsWith('bs')).forEach(key => { 1067 let pureKey = key.replace(/^bs/, ''); 1068 pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length); 1069 attributes[pureKey] = normalizeData(element.dataset[key]); 1070 }); 1071 return attributes; 1072 }, 1073 1074 getDataAttribute(element, key) { 1075 return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`)); 1076 }, 1077 1078 offset(element) { 1079 const rect = element.getBoundingClientRect(); 1080 return { 1081 top: rect.top + window.pageYOffset, 1082 left: rect.left + window.pageXOffset 1083 }; 1084 }, 1085 1086 position(element) { 1087 return { 1088 top: element.offsetTop, 1089 left: element.offsetLeft 1090 }; 1091 } 1092 1093 }; 1094 1095 return Manipulator; 1096 1097 })); 1098 1099 }(manipulator)); 1100 1101 var selectorEngine = {exports: {}}; 1102 1103 /*! 1104 * Bootstrap selector-engine.js v5.1.3 (https://getbootstrap.com/) 1105 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 1106 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 1107 */ 1108 1109 (function (module, exports) { 1110 (function (global, factory) { 1111 module.exports = factory() ; 1112 })(commonjsGlobal, (function () { 1113 /** 1114 * -------------------------------------------------------------------------- 1115 * Bootstrap (v5.1.3): util/index.js 1116 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 1117 * -------------------------------------------------------------------------- 1118 */ 1119 1120 const isElement = obj => { 1121 if (!obj || typeof obj !== 'object') { 1122 return false;
1123 } 1124 1125 if (typeof obj.jquery !== 'undefined') { 1126 obj = obj[0]; 1127 } 1128 1129 return typeof obj.nodeType !== 'undefined'; 1130 }; 1131 1132 const isVisible = element => { 1133 if (!isElement(element) || element.getClientRects().length === 0) { 1134 return false; 1135 } 1136 1137 return getComputedStyle(element).getPropertyValue('visibility') === 'visible'; 1138 }; 1139 1140 const isDisabled = element => { 1141 if (!element || element.nodeType !== Node.ELEMENT_NODE) { 1142 return true; 1143 } 1144 1145 if (element.classList.contains('disabled')) { 1146 return true; 1147 } 1148 1149 if (typeof element.disabled !== 'undefined') { 1150 return element.disabled; 1151 } 1152 1153 return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'; 1154 }; 1155 1156 /** 1157 * -------------------------------------------------------------------------- 1158 * Bootstrap (v5.1.3): dom/selector-engine.js 1159 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 1160 * -------------------------------------------------------------------------- 1161 */ 1162 const NODE_TEXT = 3; 1163 const SelectorEngine = { 1164 find(selector, element = document.documentElement) { 1165 return [].concat(...Element.prototype.querySelectorAll.call(element, selector)); 1166 }, 1167 1168 findOne(selector, element = document.documentElement) { 1169 return Element.prototype.querySelector.call(element, selector); 1170 }, 1171 1172 children(element, selector) { 1173 return [].concat(...element.children).filter(child => child.matches(selector)); 1174 }, 1175 1176 parents(element, selector) { 1177 const parents = []; 1178 let ancestor = element.parentNode; 1179 1180 while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) { 1181 if (ancestor.matches(selector)) { 1182 parents.push(ancestor); 1183 } 1184 1185 ancestor = ancestor.parentNode; 1186 } 1187 1188 return parents; 1189 }, 1190 1191 prev(element, selector) { 1192 let previous = element.previousElementSibling; 1193 1194 while (previous) { 1195 if (previous.matches(selector)) { 1196 return [previous]; 1197 } 1198 1199 previous = previous.previousElementSibling; 1200 } 1201 1202 return []; 1203 }, 1204 1205 next(element, selector) { 1206 let next = element.nextElementSibling; 1207 1208 while (next) { 1209 if (next.matches(selector)) { 1210 return [next]; 1211 } 1212 1213 next = next.nextElementSibling; 1214 } 1215 1216 return []; 1217 }, 1218 1219 focusableChildren(element) { 1220 const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(selector => `${selector}:not([tabindex^="-"])`).join(', '); 1221 return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el)); 1222 } 1223 1224 }; 1225 1226 return SelectorEngine; 1227 1228 })); 1229 1230 }(selectorEngine)); 1231 1232 /*! 1233 * Bootstrap carousel.js v5.1.3 (https://getbootstrap.com/) 1234 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 1235 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 1236 */ 1237 1238 (function (module, exports) { 1239 (function (global, factory) { 1240 module.exports = factory(eventHandler.exports, manipulator.exports, selectorEngine.exports, baseComponent.exports) ; 1241 })(commonjsGlobal, (function (EventHandler, Manipulator, SelectorEngine, BaseComponent) { 1242 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 1243 1244 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 1245 const Manipulator__default = /*#__PURE__*/_interopDefaultLegacy(Manipulator); 1246 const SelectorEngine__default = /*#__PURE__*/_interopDefaultLegacy(SelectorEngine); 1247 const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); 1248 1249 /** 1250 * -------------------------------------------------------------------------- 1251 * Bootstrap (v5.1.3): util/index.js 1252 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 1253 * -------------------------------------------------------------------------- 1254 */ 1255 const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp) 1256 1257 const toType = obj => { 1258 if (obj === null || obj === undefined) { 1259 return `${obj}`; 1260 } 1261 1262 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 1263 }; 1264 1265 const getSelector = element => { 1266 let selector = element.getAttribute('data-bs-target'); 1267 1268 if (!selector || selector === '#') { 1269 let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes, 1270 // so everything starting with `#` or `.`. If a "real" URL is used as the selector, 1271 // `document.querySelector` will rightfully complain it is invali
1271d. 1272 // See https://github.com/twbs/bootstrap/issues/32273 1273 1274 if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) { 1275 return null; 1276 } // Just in case some CMS puts out a full URL with the anchor appended 1277 1278 1279 if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) { 1280 hrefAttr = `#${hrefAttr.split('#')[1]}`; 1281 } 1282 1283 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null; 1284 } 1285 1286 return selector; 1287 }; 1288 1289 const getElementFromSelector = element => { 1290 const selector = getSelector(element); 1291 return selector ? document.querySelector(selector) : null; 1292 }; 1293 1294 const triggerTransitionEnd = element => { 1295 element.dispatchEvent(new Event(TRANSITION_END)); 1296 }; 1297 1298 const isElement = obj => { 1299 if (!obj || typeof obj !== 'object') { 1300 return false; 1301 } 1302 1303 if (typeof obj.jquery !== 'undefined') { 1304 obj = obj[0]; 1305 } 1306 1307 return typeof obj.nodeType !== 'undefined'; 1308 }; 1309 1310 const typeCheckConfig = (componentName, config, configTypes) => { 1311 Object.keys(configTypes).forEach(property => { 1312 const expectedTypes = configTypes[property]; 1313 const value = config[property]; 1314 const valueType = value && isElement(value) ? 'element' : toType(value); 1315 1316 if (!new RegExp(expectedTypes).test(valueType)) { 1317 throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); 1318 } 1319 }); 1320 }; 1321 1322 const isVisible = element => { 1323 if (!isElement(element) || element.getClientRects().length === 0) { 1324 return false; 1325 } 1326 1327 return getComputedStyle(element).getPropertyValue('visibility') === 'visible'; 1328 }; 1329 /** 1330 * Trick to restart an element's animation 1331 * 1332 * @param {HTMLElement} element 1333 * @return void 1334 * 1335 * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation 1336 */ 1337 1338 1339 const reflow = element => { 1340 // eslint-disable-next-line no-unused-expressions 1341 element.offsetHeight; 1342 }; 1343 1344 const getjQuery = () => { 1345 const { 1346 jQuery 1347 } = window; 1348 1349 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 1350 return jQuery; 1351 } 1352 1353 return null; 1354 }; 1355 1356 const DOMContentLoadedCallbacks = []; 1357 1358 const onDOMContentLoaded = callback => { 1359 if (document.readyState === 'loading') { 1360 // add listener on the first call when the document is in loading state 1361 if (!DOMContentLoadedCallbacks.length) { 1362 document.addEventListener('DOMContentLoaded', () => { 1363 DOMContentLoadedCallbacks.forEach(callback => callback()); 1364 }); 1365 } 1366 1367 DOMContentLoadedCallbacks.push(callback); 1368 } else { 1369 callback(); 1370 } 1371 }; 1372 1373 const isRTL = () => document.documentElement.dir === 'rtl'; 1374 1375 const defineJQueryPlugin = plugin => { 1376 onDOMContentLoaded(() => { 1377 const $ = getjQuery(); 1378 /* istanbul ignore if */ 1379 1380 if ($) { 1381 const name = plugin.NAME; 1382 const JQUERY_NO_CONFLICT = $.fn[name]; 1383 $.fn[name] = plugin.jQueryInterface; 1384 $.fn[name].Constructor = plugin; 1385 1386 $.fn[name].noConflict = () => { 1387 $.fn[name] = JQUERY_NO_CONFLICT; 1388 return plugin.jQueryInterface; 1389 }; 1390 } 1391 }); 1392 }; 1393 /** 1394 * Return the previous/next element of a list. 1395 * 1396 * @param {array} list The list of elements 1397 * @param activeElement The active element 1398 * @param shouldGetNext Choose to get next or previous element 1399 * @param isCycleAllowed 1400 * @return {Element|elem} The proper element 1401 */ 1402 1403 1404 const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => { 1405 let index = list.indexOf(activeElement); // if the element does not exist in the list return an element depending on the direction and if cycle is allowed 1406 1407 if (index === -1) { 1408 return list[!shouldGetNext && isCycleAllowed ? list.length - 1 : 0]; 1409 } 1410 1411 const listLength = list.length; 1412 index += shouldGetNext ? 1 : -1; 1413 1414 if (isCycleAllowed) { 1415 index = (index + listLength) % listLength; 1416 } 1417 1418 return list[Math.max(0, Math.min(index, listLength - 1))]; 1419 }; 1420 1421 /** 1422 * -------------------------------------------------------------------------- 1423 * Bootstrap (v5.1.3): carousel.js 1424 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 1425 * -------------------------------------------------------------------------- 1426 */ 1427 /** 1428 * ------------------------------------------------------------------------ 1429 * Constants 1430 * ------------------------------------------------------------------------ 1431 */ 1432 1433 const NAME = 'carousel'; 1434 const DATA_KEY = 'bs.carousel'; 1435 const EVENT_KEY = `.${DATA_KEY}`; 1436 const DATA_API_KEY = '.data-api'; 1437 const ARROW_LEFT_KEY = 'ArrowLeft'; 1438 const ARROW_RIGHT_KEY = 'ArrowRight'; 1439 const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch 1440 1441 const SWIPE_THRESHOLD = 40; 1442 const Default = { 1443 interval: 5000, 1444 keyboard: true, 1445 slide: false, 1446 pause: 'hover', 1447 wrap: true, 1448 touch: true 1449 }; 1450 const DefaultType = { 1451 interval: '(number|boolean)', 1452 keyboard: 'boolean', 1453 slide: '(boolean|string)', 1454 pause: '(string|boolean)', 1455 wrap: 'boolean', 1456 touch: 'boolean' 1457 }; 1458 const ORDER_NEXT = 'next'; 1459 const ORDER_PREV = 'prev'; 1460 const DIRECTION_LEFT = 'left'; 1461 const DIRECTION_RIGHT = 'right'; 1462 const KEY_TO_DIRECTION = { 1463 [ARROW_LEFT_KEY]: DIRECTION_RIGHT, 1464 [ARROW_RIGHT_KEY]: DIRECTION_LEFT 1465 }; 1466 const EVENT_SLIDE = `slide${EVENT_KEY}`; 1467 const EVENT_SLID = `slid${EVENT_KEY}`; 1468 const EVENT_KEYDOWN = `keydown${EVENT_KEY}`; 1469 const EVENT_MOUSEENTER = `mouseenter${EVENT_KEY}`; 1470 const EVENT_MOUSELEAVE = `mouseleave${EVENT_KEY}`; 1471 const EVENT_TOUCHSTART = `touchstart${EVENT_KEY}`; 1472 const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY}`; 1473 const EVENT_TOUCHEND = `touchend${EVENT_KEY}`; 1474 const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY}`; 1475 const EVENT_POINTERUP = `pointerup${EVENT_KEY}`; 1476 const EVENT_DRAG_START = `dragstart${EVENT_KEY}`; 1477 const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`; 1478 const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`; 1479 const CLASS_NAME_CAROUSEL = 'carousel'; 1480 const CLASS_NAME_ACTIVE = 'active'; 1481 const CLASS_NAME_SLIDE = 'slide'; 1482 const CLASS_NAME_END = 'carousel-item-end'; 1483 const CLASS_NAME_START = 'carousel-item-start'; 1484 const CLASS_NAME_NEXT = 'carousel-item-next'; 1485 const CLASS_NAME_PREV = 'carousel-item-prev'; 1486 const CLASS_NAME_POINTER_EVENT = 'pointer-event'; 1487 const SELECTOR_ACTIVE = '.active'; 1488 const SELECTOR_ACTIVE_ITEM = '.active.carousel-item';
1489 const SELECTOR_ITEM = '.carousel-item'; 1490 const SELECTOR_ITEM_IMG = '.carousel-item img'; 1491 const SELECTOR_NEXT_PREV = '.carousel-item-next, .carousel-item-prev'; 1492 const SELECTOR_INDICATORS = '.carousel-indicators'; 1493 const SELECTOR_INDICATOR = '[data-bs-target]'; 1494 const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]'; 1495 const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]'; 1496 const POINTER_TYPE_TOUCH = 'touch'; 1497 const POINTER_TYPE_PEN = 'pen'; 1498 /** 1499 * ------------------------------------------------------------------------ 1500 * Class Definition 1501 * ------------------------------------------------------------------------ 1502 */ 1503 1504 class Carousel extends BaseComponent__default.default { 1505 constructor(element, config) { 1506 super(element); 1507 this._items = null; 1508 this._interval = null; 1509 this._activeElement = null; 1510 this._isPaused = false; 1511 this._isSliding = false; 1512 this.touchTimeout = null; 1513 this.touchStartX = 0; 1514 this.touchDeltaX = 0; 1515 this._config = this._getConfig(config); 1516 this._indicatorsElement = SelectorEngine__default.default.findOne(SELECTOR_INDICATORS, this._element); 1517 this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0; 1518 this._pointerEvent = Boolean(window.PointerEvent); 1519 1520 this._addEventListeners(); 1521 } // Getters 1522 1523 1524 static get Default() { 1525 return Default; 1526 } 1527 1528 static get NAME() { 1529 return NAME; 1530 } // Public 1531 1532 1533 next() { 1534 this._slide(ORDER_NEXT); 1535 } 1536 1537 nextWhenVisible() { 1538 // Don't call next when the page isn't visible 1539 // or the carousel or its parent isn't visible 1540 if (!document.hidden && isVisible(this._element)) { 1541 this.next(); 1542 } 1543 } 1544 1545 prev() { 1546 this._slide(ORDER_PREV); 1547 } 1548 1549 pause(event) { 1550 if (!event) { 1551 this._isPaused = true; 1552 } 1553 1554 if (SelectorEngine__default.default.findOne(SELECTOR_NEXT_PREV, this._element)) { 1555 triggerTransitionEnd(this._element); 1556 this.cycle(true); 1557 } 1558 1559 clearInterval(this._interval); 1560 this._interval = null; 1561 } 1562 1563 cycle(event) { 1564 if (!event) { 1565 this._isPaused = false; 1566 } 1567 1568 if (this._interval) { 1569 clearInterval(this._interval); 1570 this._interval = null; 1571 } 1572 1573 if (this._config && this._config.interval && !this._isPaused) { 1574 this._updateInterval(); 1575 1576 this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval); 1577 } 1578 } 1579 1580 to(index) { 1581 this._activeElement = SelectorEngine__default.default.findOne(SELECTOR_ACTIVE_ITEM, this._element); 1582 1583 const activeIndex = this._getItemIndex(this._activeElement); 1584 1585 if (index > this._items.length - 1 || index < 0) { 1586 return; 1587 } 1588 1589 if (this._isSliding) { 1590 EventHandler__default.default.one(this._element, EVENT_SLID, () => this.to(index)); 1591 return; 1592 } 1593 1594 if (activeIndex === index) { 1595 this.pause(); 1596 this.cycle(); 1597 return; 1598 } 1599 1600 const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV; 1601 1602 this._slide(order, this._items[index]); 1603 } // Private 1604 1605 1606 _getConfig(config) { 1607 config = { ...Default, 1608 ...Manipulator__default.default.getDataAttributes(this._element), 1609 ...(typeof config === 'object' ? config : {}) 1610 }; 1611 typeCheckConfig(NAME, config, DefaultType); 1612 return config; 1613 } 1614 1615 _handleSwipe() { 1616 const absDeltax = Math.abs(this.touchDeltaX); 1617 1618 if (absDeltax <= SWIPE_THRESHOLD) { 1619 return; 1620 } 1621 1622 const direction = absDeltax / this.touchDeltaX; 1623 this.touchDeltaX = 0; 1624 1625 if (!direction) { 1626 return; 1627 } 1628 1629 this._slide(direction > 0 ? DIRECTION_RIGHT : DIRECTION_LEFT); 1630 } 1631 1632 _addEventListeners() { 1633 if (this._config.keyboard) { 1634 EventHandler__default.default.on(this._element, EVENT_KEYDOWN, event =>
1634 this._keydown(event)); 1635 } 1636 1637 if (this._config.pause === 'hover') { 1638 EventHandler__default.default.on(this._element, EVENT_MOUSEENTER, event => this.pause(event)); 1639 EventHandler__default.default.on(this._element, EVENT_MOUSELEAVE, event => this.cycle(event)); 1640 } 1641 1642 if (this._config.touch && this._touchSupported) { 1643 this._addTouchEventListeners(); 1644 } 1645 } 1646 1647 _addTouchEventListeners() { 1648 const hasPointerPenTouch = event => { 1649 return this._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH); 1650 }; 1651 1652 const start = event => { 1653 if (hasPointerPenTouch(event)) { 1654 this.touchStartX = event.clientX; 1655 } else if (!this._pointerEvent) { 1656 this.touchStartX = event.touches[0].clientX; 1657 } 1658 }; 1659 1660 const move = event => { 1661 // ensure swiping with one touch and not pinching 1662 this.touchDeltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this.touchStartX; 1663 }; 1664 1665 const end = event => { 1666 if (hasPointerPenTouch(event)) { 1667 this.touchDeltaX = event.clientX - this.touchStartX; 1668 } 1669 1670 this._handleSwipe(); 1671 1672 if (this._config.pause === 'hover') { 1673 // If it's a touch-enabled device, mouseenter/leave are fired as 1674 // part of the mouse compatibility events on first tap - the carousel 1675 // would stop cycling until user tapped out of it; 1676 // here, we listen for touchend, explicitly pause the carousel 1677 // (as if it's the second time we tap on it, mouseenter compat event 1678 // is NOT fired) and after a timeout (to allow for mouse compatibility 1679 // events to fire) we explicitly restart cycling 1680 this.pause(); 1681 1682 if (this.touchTimeout) { 1683 clearTimeout(this.touchTimeout); 1684 } 1685 1686 this.touchTimeout = setTimeout(event => this.cycle(event), TOUCHEVENT_COMPAT_WAIT + this._config.interval); 1687 } 1688 }; 1689 1690 SelectorEngine__default.default.find(SELECTOR_ITEM_IMG, this._element).forEach(itemImg => { 1691 EventHandler__default.default.on(itemImg, EVENT_DRAG_START, event => event.preventDefault()); 1692 }); 1693 1694 if (this._pointerEvent) { 1695 EventHandler__default.default.on(this._element, EVENT_POINTERDOWN, event => start(event)); 1696 EventHandler__default.default.on(this._element, EVENT_POINTERUP, event => end(event)); 1697 1698 this._element.classList.add(CLASS_NAME_POINTER_EVENT); 1699 } else { 1700 EventHandler__default.default.on(this._element, EVENT_TOUCHSTART, event => start(event)); 1701 EventHandler__default.default.on(this._element, EVENT_TOUCHMOVE, event => move(event)); 1702 EventHandler__default.default.on(this._element, EVENT_TOUCHEND, event => end(event)); 1703 } 1704 } 1705 1706 _keydown(event) { 1707 if (/input|textarea/i.test(event.target.tagName)) { 1708 return; 1709 } 1710 1711 const direction = KEY_TO_DIRECTION[event.key]; 1712 1713 if (direction) { 1714 event.preventDefault(); 1715 1716 this._slide(direction); 1717 } 1718 } 1719 1720 _getItemIndex(element) { 1721 this._items = element && element.parentNode ? SelectorEngine__default.default.find(SELECTOR_ITEM, element.parentNode) : []; 1722 return this._items.indexOf(element); 1723 } 1724 1725 _getItemByOrder(order, activeElement) { 1726 const isNext = order === ORDER_NEXT; 1727 return getNextActiveElement(this._items, activeElement, isNext, this._config.wrap); 1728 } 1729 1730 _triggerSlideEvent(relatedTarget, eventDirectionName) { 1731 const targetIndex = this._getItemIndex(relatedTarget); 1732 1733 const fromIndex = this._getItemIndex(SelectorEngine__default.default.findOne(SELECTOR_ACTIVE_ITEM, this._element)); 1734 1735 return EventHandler__default.default.trigger(this._element, EVENT_SLIDE, { 1736 relatedTarget, 1737 direction: eventDirectionName, 1738 from: fromIndex, 1739 to: targetIndex 1740 }); 1741 } 1742 1743 _setActiveIndicatorElement(element) { 1744 if (this._indicatorsElement) { 1745 const activeIndicator = SelectorEngine__default.default.findOne(SELECTOR_ACTIVE, this._indicatorsElement); 1746 activeIndicator.classList.remove(CLASS_NAME_ACTIVE); 1747 activeIndicator.removeAttribute('aria-current'); 1748 const indicators = SelectorEngine__default.default.find(SELECTOR_INDICATOR, this._indicatorsElement); 1749 1750 for (let i = 0; i < indicators.length; i++) { 1751 if (Number.parseInt(indicators[i].getAttribute('data-bs-slide-to'), 10) === this._getItemIndex(element)) { 1752 indicators[i].classList.add(CLASS_NAME_ACTIVE); 1753 indicators[i].setAttribute('aria-current', 'true'); 1754 break; 1755 } 1756 } 1757 } 1758 } 1759 1760 _updateInterval() { 1761 const element = this._activeElement || SelectorEngine__default.default.findOne(SELECTOR_ACTIVE_ITEM, this._element); 1762 1763 if (!element) { 1764 return; 1765 } 1766 1767 const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10); 1768 1769 if (elementInterval) { 1770 this._config.defaultInterval = this._config.defaultInterval || this._config.interval; 1771 this._config.interval = elementInterval; 1772 } else { 1773 this._config.interval = this._config.defaultInterval || this._config.interval; 1774 } 1775 } 1776 1777 _slide(directionOrOrder, element) { 1778 const order = this._directionToOrder(directionOrOrder); 1779 1780 const activeElement = SelectorEngine__default.default.findOne(SELECTOR_ACTIVE_ITEM, this._element); 1781 1782 const activeElementIndex = this._getItemIndex(activeElement); 1783 1784 const nextElement = element || this._getItemByOrder(order, activeElement); 1785 1786 const nextElementIndex = this._getItemIndex(nextElement); 1787 1788 const isCycling = Boolean(this._interval); 1789 const isNext = order === ORDER_NEXT; 1790 const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END; 1791 const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV; 1792 1793 const eventDirectionName = this._orderToDirection(order); 1794 1795 if (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE)) { 1796 this._isSliding = false;
1797 return; 1798 } 1799 1800 if (this._isSliding) { 1801 return; 1802 } 1803 1804 const slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName); 1805 1806 if (slideEvent.defaultPrevented) { 1807 return; 1808 } 1809 1810 if (!activeElement || !nextElement) { 1811 // Some weirdness is happening, so we bail 1812 return; 1813 } 1814 1815 this._isSliding = true; 1816 1817 if (isCycling) { 1818 this.pause(); 1819 } 1820 1821 this._setActiveIndicatorElement(nextElement); 1822 1823 this._activeElement = nextElement; 1824 1825 const triggerSlidEvent = () => { 1826 EventHandler__default.default.trigger(this._element, EVENT_SLID, { 1827 relatedTarget: nextElement, 1828 direction: eventDirectionName, 1829 from: activeElementIndex, 1830 to: nextElementIndex 1831 }); 1832 }; 1833 1834 if (this._element.classList.contains(CLASS_NAME_SLIDE)) { 1835 nextElement.classList.add(orderClassName); 1836 reflow(nextElement); 1837 activeElement.classList.add(directionalClassName); 1838 nextElement.classList.add(directionalClassName); 1839 1840 const completeCallBack = () => { 1841 nextElement.classList.remove(directionalClassName, orderClassName); 1842 nextElement.classList.add(CLASS_NAME_ACTIVE); 1843 activeElement.classList.remove(CLASS_NAME_ACTIVE, orderClassName, directionalClassName); 1844 this._isSliding = false; 1845 setTimeout(triggerSlidEvent, 0); 1846 }; 1847 1848 this._queueCallback(completeCallBack, activeElement, true); 1849 } else { 1850 activeElement.classList.remove(CLASS_NAME_ACTIVE); 1851 nextElement.classList.add(CLASS_NAME_ACTIVE); 1852 this._isSliding = false; 1853 triggerSlidEvent(); 1854 } 1855 1856 if (isCycling) { 1857 this.cycle(); 1858 } 1859 } 1860 1861 _directionToOrder(direction) { 1862 if (![DIRECTION_RIGHT, DIRECTION_LEFT].includes(direction)) { 1863 return direction; 1864 } 1865 1866 if (isRTL()) { 1867 return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT; 1868 } 1869 1870 return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV; 1871 } 1872 1873 _orderToDirection(order) { 1874 if (![ORDER_NEXT, ORDER_PREV].includes(order)) { 1875 return order; 1876 } 1877 1878 if (isRTL()) { 1879 return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT; 1880 } 1881 1882 return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT; 1883 } // Static 1884 1885 1886 static carouselInterface(element, config) { 1887 const data = Carousel.getOrCreateInstance(element, config); 1888 let { 1889 _config 1890 } = data; 1891 1892 if (typeof config === 'object') { 1893 _config = { ..._config, 1894 ...config 1895 }; 1896 } 1897 1898 const action = typeof config === 'string' ? config : _config.slide; 1899 1900 if (typeof config === 'number') { 1901 data.to(config); 1902 } else if (typeof action === 'string') { 1903 if (typeof data[action] === 'undefined') { 1904 throw new TypeError(`No method named "${action}"`); 1905 } 1906 1907 data[action](); 1908 } else if (_config.interval && _config.ride) { 1909 data.pause(); 1910 data.cycle(); 1911 } 1912 } 1913 1914 static jQueryInterface(config) { 1915 return this.each(function () { 1916 Carousel.carouselInterface(this, config); 1917 }); 1918 } 1919 1920 static dataApiClickHandler(event) { 1921 const target = getElementFromSelector(this); 1922 1923 if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) { 1924 return; 1925 } 1926 1927 const config = { ...Manipulator__default.default.getDataAttributes(target), 1928 ...Manipulator__default.default.getDataAttributes(this) 1929 }; 1930 const slideIndex = this.getAttribute('data-bs-slide-to'); 1931 1932 if (slideIndex) { 1933 config.interval = false; 1934 } 1935 1936 Carousel.carouselInterface(target, config); 1937 1938 if (slideIndex) { 1939 Carousel.getInstance(target).to(slideIndex); 1940 } 1941 1942 event.preventDefault(); 1943 } 1944 1945 } 1946 /** 1947 * ------------------------------------------------------------------------ 1948 * Data Api implementation 1949 * ------------------------------------------------------------------------ 1950 */ 1951 1952 1953 EventHandler__default.default.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, Carousel.dataApiClickHandler); 1954 EventHandler__default.default.on(window, EVENT_LOAD_DATA_API, () => { 1955 const carousels = SelectorEngine__default.default.find(SELECTOR_DATA_RIDE); 1956 1957 for (let i = 0, len = carousels.length; i < len; i++) {
1958 Carousel.carouselInterface(carousels[i], Carousel.getInstance(carousels[i])); 1959 } 1960 }); 1961 /** 1962 * ------------------------------------------------------------------------ 1963 * jQuery 1964 * ------------------------------------------------------------------------ 1965 * add .Carousel to jQuery only if jQuery is present 1966 */ 1967 1968 defineJQueryPlugin(Carousel); 1969 1970 return Carousel; 1971 1972 })); 1973 1974 }(carousel$1)); 1975 1976 var carousel = carousel$1.exports; 1977 1978 var collapse$1 = {exports: {}}; 1979 1980 /*! 1981 * Bootstrap collapse.js v5.1.3 (https://getbootstrap.com/) 1982 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 1983 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 1984 */ 1985 1986 (function (module, exports) { 1987 (function (global, factory) { 1988 module.exports = factory(data.exports, eventHandler.exports, manipulator.exports, selectorEngine.exports, baseComponent.exports) ; 1989 })(commonjsGlobal, (function (Data, EventHandler, Manipulator, SelectorEngine, BaseComponent) { 1990 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 1991 1992 const Data__default = /*#__PURE__*/_interopDefaultLegacy(Data); 1993 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 1994 const Manipulator__default = /*#__PURE__*/_interopDefaultLegacy(Manipulator); 1995 const SelectorEngine__default = /*#__PURE__*/_interopDefaultLegacy(SelectorEngine); 1996 const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); 1997 1998 /** 1999 * -------------------------------------------------------------------------- 2000 * Bootstrap (v5.1.3): util/index.js 2001 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 2002 * -------------------------------------------------------------------------- 2003 */ 2004 2005 const toType = obj => { 2006 if (obj === null || obj === undefined) { 2007 return `${obj}`; 2008 } 2009 2010 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 2011 }; 2012 2013 const getSelector = element => { 2014 let selector = element.getAttribute('data-bs-target'); 2015 2016 if (!selector || selector === '#') { 2017 let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes, 2018 // so everything starting with `#` or `.`. If a "real" URL is used as the selector, 2019 // `document.querySelector` will rightfully complain it is invalid. 2020 // See https://github.com/twbs/bootstrap/issues/32273 2021 2022 if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) { 2023 return null; 2024 } // Just in case some CMS puts out a full URL with the anchor appended 2025 2026 2027 if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) { 2028 hrefAttr = `#${hrefAttr.split('#')[1]}`; 2029 } 2030 2031 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null; 2032 } 2033 2034 return selector; 2035 }; 2036 2037 const getSelectorFromElement = element => { 2038 const selector = getSelector(element); 2039 2040 if (selector) { 2041 return document.querySelector(selector) ? selector : null; 2042 } 2043 2044 return null; 2045 }; 2046 2047 const getElementFromSelector = element => { 2048 const selector = getSelector(element); 2049 return selector ? document.querySelector(selector) : null; 2050 }; 2051 2052 const isElement = obj => { 2053 if (!obj || typeof obj !== 'object') { 2054 return false; 2055 } 2056 2057 if (typeof obj.jquery !== 'undefined') { 2058 obj = obj[0]; 2059 } 2060 2061 return typeof obj.nodeType !== 'undefined'; 2062 }; 2063 2064 const getElement = obj => { 2065 if (isElement(obj)) { 2066 // it's a jQuery object or a node element 2067 return obj.jquery ? obj[0] : obj; 2068 } 2069 2070 if (typeof obj === 'string' && obj.length > 0) { 2071 return document.querySelector(obj); 2072 } 2073 2074 return null; 2075 }; 2076 2077 const typeCheckConfig = (componentName, config, configTypes) => { 2078 Object.keys(configTypes).forEach(property => { 2079 const expectedTypes = configTypes[property]; 2080 const value = config[property]; 2081 const valueType = value && isElement(value) ? 'element' : toType(value); 2082 2083 if (!new RegExp(expectedTypes).test(valueType)) { 2084 throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); 2085 } 2086 }); 2087 }; 2088 /** 2089 * Trick to restart an element's animation 2090 * 2091 * @param {HTMLElement} element 2092 * @return void 2093 * 2094 * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation 2095 */ 2096 2097
2098 const reflow = element => { 2099 // eslint-disable-next-line no-unused-expressions 2100 element.offsetHeight; 2101 }; 2102 2103 const getjQuery = () => { 2104 const { 2105 jQuery 2106 } = window; 2107 2108 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 2109 return jQuery; 2110 } 2111 2112 return null; 2113 }; 2114 2115 const DOMContentLoadedCallbacks = []; 2116 2117 const onDOMContentLoaded = callback => { 2118 if (document.readyState === 'loading') { 2119 // add listener on the first call when the document is in loading state 2120 if (!DOMContentLoadedCallbacks.length) { 2121 document.addEventListener('DOMContentLoaded', () => { 2122 DOMContentLoadedCallbacks.forEach(callback => callback()); 2123 }); 2124 } 2125 2126 DOMContentLoadedCallbacks.push(callback); 2127 } else { 2128 callback(); 2129 } 2130 }; 2131 2132 const defineJQueryPlugin = plugin => { 2133 onDOMContentLoaded(() => { 2134 const $ = getjQuery(); 2135 /* istanbul ignore if */ 2136 2137 if ($) { 2138 const name = plugin.NAME; 2139 const JQUERY_NO_CONFLICT = $.fn[name]; 2140 $.fn[name] = plugin.jQueryInterface; 2141 $.fn[name].Constructor = plugin; 2142 2143 $.fn[name].noConflict = () => { 2144 $.fn[name] = JQUERY_NO_CONFLICT; 2145 return plugin.jQueryInterface; 2146 }; 2147 } 2148 }); 2149 }; 2150 2151 /** 2152 * -------------------------------------------------------------------------- 2153 * Bootstrap (v5.1.3): collapse.js 2154 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 2155 * -------------------------------------------------------------------------- 2156 */ 2157 /** 2158 * ------------------------------------------------------------------------ 2159 * Constants 2160 * ------------------------------------------------------------------------ 2161 */ 2162 2163 const NAME = 'collapse'; 2164 const DATA_KEY = 'bs.collapse'; 2165 const EVENT_KEY = `.${DATA_KEY}`; 2166 const DATA_API_KEY = '.data-api'; 2167 const Default = { 2168 toggle: true, 2169 parent: null 2170 }; 2171 const DefaultType = { 2172 toggle: 'boolean', 2173 parent: '(null|element)' 2174 }; 2175 const EVENT_SHOW = `show${EVENT_KEY}`; 2176 const EVENT_SHOWN = `shown${EVENT_KEY}`; 2177 const EVENT_HIDE = `hide${EVENT_KEY}`; 2178 const EVENT_HIDDEN = `hidden${EVENT_KEY}`; 2179 const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`; 2180 const CLASS_NAME_SHOW = 'show'; 2181 const CLASS_NAME_COLLAPSE = 'collapse'; 2182 const CLASS_NAME_COLLAPSING = 'collapsing'; 2183 const CLASS_NAME_COLLAPSED = 'collapsed'; 2184 const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`; 2185 const CLASS_NAME_HORIZONTAL = 'collapse-horizontal'; 2186 const WIDTH = 'width'; 2187 const HEIGHT = 'height'; 2188 const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing'; 2189 const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="collapse"]'; 2190 /** 2191 * ------------------------------------------------------------------------ 2192 * Class Definition 2193 * ------------------------------------------------------------------------ 2194 */ 2195 2196 class Collapse extends BaseComponent__default.default { 2197 constructor(element, config) { 2198 super(element); 2199 this._isTransitioning = false; 2200 this._config = this._getConfig(config); 2201 this._triggerArray = []; 2202 const toggleList = SelectorEngine__default.default.find(SELECTOR_DATA_TOGGLE); 2203 2204 for (let i = 0, len = toggleList.length; i < len; i++) { 2205 const elem = toggleList[i]; 2206 const selector = getSelectorFromElement(elem); 2207 const filterElement = SelectorEngine__default.default.find(selector).filter(foundElem => foundElem === this._element); 2208 2209 if (selector !== null && filterElement.length) { 2210 this._selector = selector; 2211 2212 this._triggerArray.push(elem); 2213 } 2214 } 2215 2216 this._initializeChildren(); 2217 2218 if (!this._config.parent) { 2219 this._addAriaAndCollapsedClass(this._triggerArray, this._isShown()); 2220 } 2221 2222 if (this._config.toggle) { 2223 this.toggle(); 2224 } 2225 } // Getters 2226 2227 2228 static get Default() { 2229 return Default; 2230 } 2231 2232 static get NAME() { 2233 return NAME; 2234 } // Public 2235 2236 2237 toggle() { 2238 if (this._isShown()) { 2239 this.hide(); 2240 } else { 2241 this.show(); 2242 } 2243 } 2244 2245 show() { 2246 if (this._isTransitioning || this._isShown()) { 2247 return; 2248 } 2249 2250 let actives = []; 2251 let activesData; 2252 2253 if (this._config.parent) { 2254 const children = SelectorEngine__default.default.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent); 2255 actives = SelectorEngine__default.default.find(SELECTOR_ACTIVES, this._config.parent).filter(elem => !children.includes(elem)); // remove children if greater depth 2256 } 2257 2258 const container = SelectorEngine__default.default.findOne(this._selector); 2259 2260 if (actives.length) { 2261 const tempActiveData = actives.find(elem => container !== elem); 2262 activesData = tempActiveData ? Collapse.getInstance(tempActiveData) : null; 2263 2264 if (activesData && activesData._isTransitioning) { 2265 return; 2266 } 2267 } 2268 2269 const startEvent = EventHandler__default.default.trigger(this._element, EVENT_SHOW); 2270 2271 if (startEvent.defaultPrevented) { 2272 return; 2273 } 2274
2275 actives.forEach(elemActive => { 2276 if (container !== elemActive) { 2277 Collapse.getOrCreateInstance(elemActive, { 2278 toggle: false 2279 }).hide(); 2280 } 2281 2282 if (!activesData) { 2283 Data__default.default.set(elemActive, DATA_KEY, null); 2284 } 2285 }); 2286 2287 const dimension = this._getDimension(); 2288 2289 this._element.classList.remove(CLASS_NAME_COLLAPSE); 2290 2291 this._element.classList.add(CLASS_NAME_COLLAPSING); 2292 2293 this._element.style[dimension] = 0; 2294 2295 this._addAriaAndCollapsedClass(this._triggerArray, true); 2296 2297 this._isTransitioning = true; 2298 2299 const complete = () => { 2300 this._isTransitioning = false; 2301 2302 this._element.classList.remove(CLASS_NAME_COLLAPSING); 2303 2304 this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW); 2305 2306 this._element.style[dimension] = ''; 2307 EventHandler__default.default.trigger(this._element, EVENT_SHOWN); 2308 }; 2309 2310 const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1); 2311 const scrollSize = `scroll${capitalizedDimension}`; 2312 2313 this._queueCallback(complete, this._element, true); 2314 2315 this._element.style[dimension] = `${this._element[scrollSize]}px`; 2316 } 2317 2318 hide() { 2319 if (this._isTransitioning || !this._isShown()) { 2320 return; 2321 } 2322 2323 const startEvent = EventHandler__default.default.trigger(this._element, EVENT_HIDE); 2324 2325 if (startEvent.defaultPrevented) { 2326 return; 2327 } 2328 2329 const dimension = this._getDimension(); 2330 2331 this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`; 2332 reflow(this._element); 2333 2334 this._element.classList.add(CLASS_NAME_COLLAPSING); 2335 2336 this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW); 2337 2338 const triggerArrayLength = this._triggerArray.length; 2339 2340 for (let i = 0; i < triggerArrayLength; i++) { 2341 const trigger = this._triggerArray[i]; 2342 const elem = getElementFromSelector(trigger); 2343 2344 if (elem && !this._isShown(elem)) { 2345 this._addAriaAndCollapsedClass([trigger], false); 2346 } 2347 } 2348 2349 this._isTransitioning = true; 2350 2351 const complete = () => { 2352 this._isTransitioning = false; 2353 2354 this._element.classList.remove(CLASS_NAME_COLLAPSING); 2355 2356 this._element.classList.add(CLASS_NAME_COLLAPSE); 2357 2358 EventHandler__default.default.trigger(this._element, EVENT_HIDDEN); 2359 }; 2360 2361 this._element.style[dimension] = ''; 2362 2363 this._queueCallback(complete, this._element, true); 2364 } 2365 2366 _isShown(element = this._element) { 2367 return element.classList.contains(CLASS_NAME_SHOW); 2368 } // Private 2369 2370 2371 _getConfig(config) { 2372 config = { ...Default, 2373 ...Manipulator__default.default.getDataAttributes(this._element), 2374 ...config 2375 }; 2376 config.toggle = Boolean(config.toggle); // Coerce string values 2377 2378 config.parent = getElement(config.parent); 2379 typeCheckConfig(NAME, config, DefaultType); 2380 return config; 2381 } 2382 2383 _getDimension() { 2384 return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT; 2385 } 2386 2387 _initializeChildren() { 2388 if (!this._config.parent) { 2389 return; 2390 } 2391 2392 const children = SelectorEngine__default.default.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent); 2393 SelectorEngine__default.default.find(SELECTOR_DATA_TOGGLE, this._config.parent).filter(elem => !children.includes(elem)).forEach(element => { 2394 const selected = getElementFromSelector(element); 2395 2396 if (selected) { 2397 this._addAriaAndCollapsedClass([element], this._isShown(selected)); 2398 } 2399 }); 2400 } 2401 2402 _addAriaAndCollapsedClass(triggerArray, isOpen) { 2403 if (!triggerArray.length) { 2404 return; 2405 } 2406 2407 triggerArray.forEach(elem => { 2408 if (isOpen) { 2409 elem.classList.remove(CLASS_NAME_COLLAPSED); 2410 } else { 2411 elem.classList.add(CLASS_NAME_COLLAPSED); 2412 } 2413 2414 elem.setAttribute('aria-expanded', isOpen); 2415 }); 2416 } // Static 2417 2418 2419 static jQueryInterface(config) { 2420 return this.each(function () { 2421 const _config = {}; 2422 2423 if (typeof config === 'string' && /show|hide/.test(config)) { 2424 _config.toggle = false;
2425 } 2426 2427 const data = Collapse.getOrCreateInstance(this, _config); 2428 2429 if (typeof config === 'string') { 2430 if (typeof data[config] === 'undefined') { 2431 throw new TypeError(`No method named "${config}"`); 2432 } 2433 2434 data[config](); 2435 } 2436 }); 2437 } 2438 2439 } 2440 /** 2441 * ------------------------------------------------------------------------ 2442 * Data Api implementation 2443 * ------------------------------------------------------------------------ 2444 */ 2445 2446 2447 EventHandler__default.default.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { 2448 // preventDefault only for <a> elements (which change the URL) not inside the collapsible element 2449 if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') { 2450 event.preventDefault(); 2451 } 2452 2453 const selector = getSelectorFromElement(this); 2454 const selectorElements = SelectorEngine__default.default.find(selector); 2455 selectorElements.forEach(element => { 2456 Collapse.getOrCreateInstance(element, { 2457 toggle: false 2458 }).toggle(); 2459 }); 2460 }); 2461 /** 2462 * ------------------------------------------------------------------------ 2463 * jQuery 2464 * ------------------------------------------------------------------------ 2465 * add .Collapse to jQuery only if jQuery is present 2466 */ 2467 2468 defineJQueryPlugin(Collapse); 2469 2470 return Collapse; 2471 2472 })); 2473 2474 }(collapse$1)); 2475 2476 var collapse = collapse$1.exports; 2477 2478 var dropdown$1 = {exports: {}}; 2479 2480 var top = 'top'; 2481 var bottom = 'bottom'; 2482 var right = 'right'; 2483 var left = 'left'; 2484 var auto = 'auto'; 2485 var basePlacements = [top, bottom, right, left]; 2486 var start = 'start'; 2487 var end = 'end'; 2488 var clippingParents = 'clippingParents'; 2489 var viewport = 'viewport'; 2490 var popper = 'popper'; 2491 var reference = 'reference'; 2492 var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) { 2493 return acc.concat([placement + "-" + start, placement + "-" + end]); 2494 }, []); 2495 var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) { 2496 return acc.concat([placement, placement + "-" + start, placement + "-" + end]); 2497 }, []); // modifiers that need to read the DOM 2498 2499 var beforeRead = 'beforeRead'; 2500 var read = 'read'; 2501 var afterRead = 'afterRead'; // pure-logic modifiers 2502 2503 var beforeMain = 'beforeMain'; 2504 var main = 'main'; 2505 var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state) 2506 2507 var beforeWrite = 'beforeWrite'; 2508 var write = 'write'; 2509 var afterWrite = 'afterWrite'; 2510 var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite]; 2511 2512 function getNodeName(element) { 2513 return element ? (element.nodeName || '').toLowerCase() : null; 2514 } 2515 2516 function getWindow(node) { 2517 if (node == null) { 2518 return window; 2519 } 2520 2521 if (node.toString() !== '[object Window]') { 2522 var ownerDocument = node.ownerDocument; 2523 return ownerDocument ? ownerDocument.defaultView || window : window; 2524 } 2525 2526 return node; 2527 } 2528 2529 function isElement(node) { 2530 var OwnElement = getWindow(node).Element; 2531 return node instanceof OwnElement || node instanceof Element; 2532 } 2533 2534 function isHTMLElement(node) { 2535 var OwnElement = getWindow(node).HTMLElement; 2536 return node instanceof OwnElement || node instanceof HTMLElement; 2537 } 2538 2539 function isShadowRoot(node) { 2540 // IE 11 has no ShadowRoot 2541 if (typeof ShadowRoot === 'undefined') { 2542 return false; 2543 } 2544 2545 var OwnElement = getWindow(node).ShadowRoot; 2546 return node instanceof OwnElement || node instanceof ShadowRoot; 2547 } 2548 2549 // and applies them to the HTMLElements such as popper and arrow 2550 2551 function applyStyles(_ref) { 2552 var state = _ref.state; 2553 Object.keys(state.elements).forEach(function (name) { 2554 var style = state.styles[name] || {}; 2555 var attributes = state.attributes[name] || {}; 2556 var element = state.elements[name]; // arrow is optional + virtual elements 2557 2558 if (!isHTMLElement(element) || !getNodeName(element)) { 2559 return; 2560 } // Flow doesn't support to extend this property, but it's the most 2561 // effective way to apply styles to an HTMLElement 2562 // $FlowFixMe[cannot-write] 2563 2564 2565 Object.assign(element.style, style);
vendor: 4,113 bytes, lines 2566-2720
2566 Object.keys(attributes).forEach(function (name) { 2567 var value = attributes[name]; 2568 2569 if (value === false) { 2570 element.removeAttribute(name); 2571 } else { 2572 element.setAttribute(name, value === true ? '' : value); 2573 } 2574 }); 2575 }); 2576 } 2577 2578 function effect$2(_ref2) { 2579 var state = _ref2.state; 2580 var initialStyles = { 2581 popper: { 2582 position: state.options.strategy, 2583 left: '0', 2584 top: '0', 2585 margin: '0' 2586 }, 2587 arrow: { 2588 position: 'absolute' 2589 }, 2590 reference: {} 2591 }; 2592 Object.assign(state.elements.popper.style, initialStyles.popper); 2593 state.styles = initialStyles; 2594 2595 if (state.elements.arrow) { 2596 Object.assign(state.elements.arrow.style, initialStyles.arrow); 2597 } 2598 2599 return function () { 2600 Object.keys(state.elements).forEach(function (name) { 2601 var element = state.elements[name]; 2602 var attributes = state.attributes[name] || {}; 2603 var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them 2604 2605 var style = styleProperties.reduce(function (style, property) { 2606 style[property] = ''; 2607 return style; 2608 }, {}); // arrow is optional + virtual elements 2609 2610 if (!isHTMLElement(element) || !getNodeName(element)) { 2611 return; 2612 } 2613 2614 Object.assign(element.style, style); 2615 Object.keys(attributes).forEach(function (attribute) { 2616 element.removeAttribute(attribute); 2617 }); 2618 }); 2619 }; 2620 } // eslint-disable-next-line import/no-unused-modules 2621 2622 2623 var applyStyles$1 = { 2624 name: 'applyStyles', 2625 enabled: true, 2626 phase: 'write', 2627 fn: applyStyles, 2628 effect: effect$2, 2629 requires: ['computeStyles'] 2630 }; 2631 2632 function getBasePlacement(placement) { 2633 return placement.split('-')[0]; 2634 } 2635 2636 var max = Math.max; 2637 var min = Math.min; 2638 var round = Math.round; 2639 2640 function getBoundingClientRect(element, includeScale) { 2641 if (includeScale === void 0) { 2642 includeScale = false; 2643 } 2644 2645 var rect = element.getBoundingClientRect(); 2646 var scaleX = 1; 2647 var scaleY = 1; 2648 2649 if (isHTMLElement(element) && includeScale) { 2650 var offsetHeight = element.offsetHeight; 2651 var offsetWidth = element.offsetWidth; // Do not attempt to divide by 0, otherwise we get `Infinity` as scale 2652 // Fallback to 1 in case both values are `0` 2653 2654 if (offsetWidth > 0) { 2655 scaleX = round(rect.width) / offsetWidth || 1; 2656 } 2657 2658 if (offsetHeight > 0) { 2659 scaleY = round(rect.height) / offsetHeight || 1; 2660 } 2661 } 2662 2663 return { 2664 width: rect.width / scaleX, 2665 height: rect.height / scaleY, 2666 top: rect.top / scaleY, 2667 right: rect.right / scaleX, 2668 bottom: rect.bottom / scaleY, 2669 left: rect.left / scaleX, 2670 x: rect.left / scaleX, 2671 y: rect.top / scaleY 2672 }; 2673 } 2674 2675 // means it doesn't take into account transforms. 2676 2677 function getLayoutRect(element) { 2678 var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed. 2679 // Fixes https://github.com/popperjs/popper-core/issues/1223 2680 2681 var width = element.offsetWidth; 2682 var height = element.offsetHeight; 2683 2684 if (Math.abs(clientRect.width - width) <= 1) { 2685 width = clientRect.width; 2686 } 2687 2688 if (Math.abs(clientRect.height - height) <= 1) { 2689 height = clientRect.height; 2690 } 2691 2692 return { 2693 x: element.offsetLeft, 2694 y: element.offsetTop, 2695 width: width, 2696 height: height 2697 }; 2698 } 2699 2700 function contains(parent, child) { 2701 var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method 2702 2703 if (parent.contains(child)) { 2704 return true; 2705 } // then fallback to custom implementation with Shadow DOM support 2706 else if (rootNode && isShadowRoot(rootNode)) { 2707 var next = child; 2708 2709 do { 2710 if (next && parent.isSameNode(next)) { 2711 return true; 2712 } // $FlowFixMe[prop-missing]: need a better way to handle this... 2713 2714 2715 next = next.parentNode || next.host; 2716 } while (next); 2717 } // Give up, the result is false 2718 2719 2720 return false;
vendor: 4,125 bytes, lines 2721-2847
2721 } 2722 2723 function getComputedStyle$1(element) { 2724 return getWindow(element).getComputedStyle(element); 2725 } 2726 2727 function isTableElement(element) { 2728 return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0; 2729 } 2730 2731 function getDocumentElement(element) { 2732 // $FlowFixMe[incompatible-return]: assume body is always available 2733 return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing] 2734 element.document) || window.document).documentElement; 2735 } 2736 2737 function getParentNode(element) { 2738 if (getNodeName(element) === 'html') { 2739 return element; 2740 } 2741 2742 return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle 2743 // $FlowFixMe[incompatible-return] 2744 // $FlowFixMe[prop-missing] 2745 element.assignedSlot || // step into the shadow DOM of the parent of a slotted node 2746 element.parentNode || ( // DOM Element detected 2747 isShadowRoot(element) ? element.host : null) || // ShadowRoot detected 2748 // $FlowFixMe[incompatible-call]: HTMLElement is a Node 2749 getDocumentElement(element) // fallback 2750 2751 ); 2752 } 2753 2754 function getTrueOffsetParent(element) { 2755 if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837 2756 getComputedStyle$1(element).position === 'fixed') { 2757 return null; 2758 } 2759 2760 return element.offsetParent; 2761 } // `.offsetParent` reports `null` for fixed elements, while absolute elements 2762 // return the containing block 2763 2764 2765 function getContainingBlock(element) { 2766 var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') !== -1; 2767 var isIE = navigator.userAgent.indexOf('Trident') !== -1; 2768 2769 if (isIE && isHTMLElement(element)) { 2770 // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport 2771 var elementCss = getComputedStyle$1(element); 2772 2773 if (elementCss.position === 'fixed') { 2774 return null; 2775 } 2776 } 2777 2778 var currentNode = getParentNode(element); 2779 2780 if (isShadowRoot(currentNode)) { 2781 currentNode = currentNode.host; 2782 } 2783 2784 while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) { 2785 var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that 2786 // create a containing block. 2787 // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block 2788 2789 if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') { 2790 return currentNode; 2791 } else { 2792 currentNode = currentNode.parentNode; 2793 } 2794 } 2795 2796 return null; 2797 } // Gets the closest ancestor positioned element. Handles some edge cases, 2798 // such as table ancestors and cross browser bugs. 2799 2800 2801 function getOffsetParent(element) { 2802 var window = getWindow(element); 2803 var offsetParent = getTrueOffsetParent(element); 2804 2805 while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') { 2806 offsetParent = getTrueOffsetParent(offsetParent); 2807 } 2808 2809 if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static')) { 2810 return window; 2811 } 2812 2813 return offsetParent || getContainingBlock(element) || window; 2814 } 2815 2816 function getMainAxisFromPlacement(placement) { 2817 return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y'; 2818 } 2819 2820 function within(min$1, value, max$1) { 2821 return max(min$1, min(value, max$1)); 2822 } 2823 function withinMaxClamp(min, value, max) { 2824 var v = within(min, value, max); 2825 return v > max ? max : v; 2826 } 2827 2828 function getFreshSideObject() { 2829 return { 2830 top: 0, 2831 right: 0, 2832 bottom: 0, 2833 left: 0 2834 }; 2835 } 2836 2837 function mergePaddingObject(paddingObject) { 2838 return Object.assign({}, getFreshSideObject(), paddingObject); 2839 } 2840 2841 function expandToHashMap(value, keys) { 2842 return keys.reduce(function (hashMap, key) { 2843 hashMap[key] = value; 2844 return hashMap; 2845 }, {}); 2846 } 2847
vendor: 3,038 bytes, lines 2848-2937
2848 var toPaddingObject = function toPaddingObject(padding, state) { 2849 padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, { 2850 placement: state.placement 2851 })) : padding; 2852 return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); 2853 }; 2854 2855 function arrow(_ref) { 2856 var _state$modifiersData$; 2857 2858 var state = _ref.state, 2859 name = _ref.name, 2860 options = _ref.options; 2861 var arrowElement = state.elements.arrow; 2862 var popperOffsets = state.modifiersData.popperOffsets; 2863 var basePlacement = getBasePlacement(state.placement); 2864 var axis = getMainAxisFromPlacement(basePlacement); 2865 var isVertical = [left, right].indexOf(basePlacement) >= 0; 2866 var len = isVertical ? 'height' : 'width'; 2867 2868 if (!arrowElement || !popperOffsets) { 2869 return; 2870 } 2871 2872 var paddingObject = toPaddingObject(options.padding, state); 2873 var arrowRect = getLayoutRect(arrowElement); 2874 var minProp = axis === 'y' ? top : left; 2875 var maxProp = axis === 'y' ? bottom : right; 2876 var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len]; 2877 var startDiff = popperOffsets[axis] - state.rects.reference[axis]; 2878 var arrowOffsetParent = getOffsetParent(arrowElement); 2879 var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0; 2880 var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is 2881 // outside of the popper bounds 2882 2883 var min = paddingObject[minProp]; 2884 var max = clientSize - arrowRect[len] - paddingObject[maxProp]; 2885 var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference; 2886 var offset = within(min, center, max); // Prevents breaking syntax highlighting... 2887 2888 var axisProp = axis; 2889 state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$); 2890 } 2891 2892 function effect$1(_ref2) { 2893 var state = _ref2.state, 2894 options = _ref2.options; 2895 var _options$element = options.element, 2896 arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element; 2897 2898 if (arrowElement == null) { 2899 return; 2900 } // CSS selector 2901 2902 2903 if (typeof arrowElement === 'string') { 2904 arrowElement = state.elements.popper.querySelector(arrowElement); 2905 2906 if (!arrowElement) { 2907 return; 2908 } 2909 } 2910 2911 if (!contains(state.elements.popper, arrowElement)) { 2912 2913 return; 2914 } 2915 2916 state.elements.arrow = arrowElement; 2917 } // eslint-disable-next-line import/no-unused-modules 2918 2919 2920 var arrow$1 = { 2921 name: 'arrow', 2922 enabled: true, 2923 phase: 'main', 2924 fn: arrow, 2925 effect: effect$1, 2926 requires: ['popperOffsets'], 2927 requiresIfExists: ['preventOverflow'] 2928 }; 2929 2930 function getVariation(placement) { 2931 return placement.split('-')[1]; 2932 } 2933 2934 var unsetSides = { 2935 top: 'auto', 2936 right: 'auto', 2937 bottom: 'auto',
vendor: 4,248 bytes, lines 2938-3061
2938 left: 'auto' 2939 }; // Round the offsets to the nearest suitable subpixel based on the DPR. 2940 // Zooming can change the DPR, but it seems to report a value that will 2941 // cleanly divide the values into the appropriate subpixels. 2942 2943 function roundOffsetsByDPR(_ref) { 2944 var x = _ref.x, 2945 y = _ref.y; 2946 var win = window; 2947 var dpr = win.devicePixelRatio || 1; 2948 return { 2949 x: round(x * dpr) / dpr || 0, 2950 y: round(y * dpr) / dpr || 0 2951 }; 2952 } 2953 2954 function mapToStyles(_ref2) { 2955 var _Object$assign2; 2956 2957 var popper = _ref2.popper, 2958 popperRect = _ref2.popperRect, 2959 placement = _ref2.placement, 2960 variation = _ref2.variation, 2961 offsets = _ref2.offsets, 2962 position = _ref2.position, 2963 gpuAcceleration = _ref2.gpuAcceleration, 2964 adaptive = _ref2.adaptive, 2965 roundOffsets = _ref2.roundOffsets, 2966 isFixed = _ref2.isFixed; 2967 var _offsets$x = offsets.x, 2968 x = _offsets$x === void 0 ? 0 : _offsets$x, 2969 _offsets$y = offsets.y, 2970 y = _offsets$y === void 0 ? 0 : _offsets$y; 2971 2972 var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({ 2973 x: x, 2974 y: y 2975 }) : { 2976 x: x, 2977 y: y 2978 }; 2979 2980 x = _ref3.x; 2981 y = _ref3.y; 2982 var hasX = offsets.hasOwnProperty('x'); 2983 var hasY = offsets.hasOwnProperty('y'); 2984 var sideX = left; 2985 var sideY = top; 2986 var win = window; 2987 2988 if (adaptive) { 2989 var offsetParent = getOffsetParent(popper); 2990 var heightProp = 'clientHeight'; 2991 var widthProp = 'clientWidth'; 2992 2993 if (offsetParent === getWindow(popper)) { 2994 offsetParent = getDocumentElement(popper); 2995 2996 if (getComputedStyle$1(offsetParent).position !== 'static' && position === 'absolute') { 2997 heightProp = 'scrollHeight'; 2998 widthProp = 'scrollWidth'; 2999 } 3000 } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it 3001 3002 3003 offsetParent = offsetParent; 3004 3005 if (placement === top || (placement === left || placement === right) && variation === end) { 3006 sideY = bottom; 3007 var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing] 3008 offsetParent[heightProp]; 3009 y -= offsetY - popperRect.height; 3010 y *= gpuAcceleration ? 1 : -1; 3011 } 3012 3013 if (placement === left || (placement === top || placement === bottom) && variation === end) { 3014 sideX = right; 3015 var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing] 3016 offsetParent[widthProp]; 3017 x -= offsetX - popperRect.width; 3018 x *= gpuAcceleration ? 1 : -1; 3019 } 3020 } 3021 3022 var commonStyles = Object.assign({ 3023 position: position 3024 }, adaptive && unsetSides); 3025 3026 var _ref4 = roundOffsets === true ? roundOffsetsByDPR({ 3027 x: x, 3028 y: y 3029 }) : { 3030 x: x, 3031 y: y 3032 }; 3033 3034 x = _ref4.x; 3035 y = _ref4.y; 3036 3037 if (gpuAcceleration) { 3038 var _Object$assign; 3039 3040 return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign)); 3041 } 3042 3043 return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2)); 3044 } 3045 3046 function computeStyles(_ref5) { 3047 var state = _ref5.state, 3048 options = _ref5.options; 3049 var _options$gpuAccelerat = options.gpuAcceleration, 3050 gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, 3051 _options$adaptive = options.adaptive, 3052 adaptive = _options$adaptive === void 0 ? true : _options$adaptive, 3053 _options$roundOffsets = options.roundOffsets, 3054 roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets; 3055 3056 var commonStyles = { 3057 placement: getBasePlacement(state.placement), 3058 variation: getVariation(state.placement), 3059 popper: state.elements.popper, 3060 popperRect: state.rects.popper, 3061 gpuAcceleration: gpuAcceleration,
vendor: 4,102 bytes, lines 3062-3201
3062 isFixed: state.options.strategy === 'fixed' 3063 }; 3064 3065 if (state.modifiersData.popperOffsets != null) { 3066 state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, { 3067 offsets: state.modifiersData.popperOffsets, 3068 position: state.options.strategy, 3069 adaptive: adaptive, 3070 roundOffsets: roundOffsets 3071 }))); 3072 } 3073 3074 if (state.modifiersData.arrow != null) { 3075 state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, { 3076 offsets: state.modifiersData.arrow, 3077 position: 'absolute', 3078 adaptive: false, 3079 roundOffsets: roundOffsets 3080 }))); 3081 } 3082 3083 state.attributes.popper = Object.assign({}, state.attributes.popper, { 3084 'data-popper-placement': state.placement 3085 }); 3086 } // eslint-disable-next-line import/no-unused-modules 3087 3088 3089 var computeStyles$1 = { 3090 name: 'computeStyles', 3091 enabled: true, 3092 phase: 'beforeWrite', 3093 fn: computeStyles, 3094 data: {} 3095 }; 3096 3097 var passive = { 3098 passive: true 3099 }; 3100 3101 function effect(_ref) { 3102 var state = _ref.state, 3103 instance = _ref.instance, 3104 options = _ref.options; 3105 var _options$scroll = options.scroll, 3106 scroll = _options$scroll === void 0 ? true : _options$scroll, 3107 _options$resize = options.resize, 3108 resize = _options$resize === void 0 ? true : _options$resize; 3109 var window = getWindow(state.elements.popper); 3110 var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper); 3111 3112 if (scroll) { 3113 scrollParents.forEach(function (scrollParent) { 3114 scrollParent.addEventListener('scroll', instance.update, passive); 3115 }); 3116 } 3117 3118 if (resize) { 3119 window.addEventListener('resize', instance.update, passive); 3120 } 3121 3122 return function () { 3123 if (scroll) { 3124 scrollParents.forEach(function (scrollParent) { 3125 scrollParent.removeEventListener('scroll', instance.update, passive); 3126 }); 3127 } 3128 3129 if (resize) { 3130 window.removeEventListener('resize', instance.update, passive); 3131 } 3132 }; 3133 } // eslint-disable-next-line import/no-unused-modules 3134 3135 3136 var eventListeners = { 3137 name: 'eventListeners', 3138 enabled: true, 3139 phase: 'write', 3140 fn: function fn() {}, 3141 effect: effect, 3142 data: {} 3143 }; 3144 3145 var hash$1 = { 3146 left: 'right', 3147 right: 'left', 3148 bottom: 'top', 3149 top: 'bottom' 3150 }; 3151 function getOppositePlacement(placement) { 3152 return placement.replace(/left|right|bottom|top/g, function (matched) { 3153 return hash$1[matched]; 3154 }); 3155 } 3156 3157 var hash = { 3158 start: 'end', 3159 end: 'start' 3160 }; 3161 function getOppositeVariationPlacement(placement) { 3162 return placement.replace(/start|end/g, function (matched) { 3163 return hash[matched]; 3164 }); 3165 } 3166 3167 function getWindowScroll(node) { 3168 var win = getWindow(node); 3169 var scrollLeft = win.pageXOffset; 3170 var scrollTop = win.pageYOffset; 3171 return { 3172 scrollLeft: scrollLeft, 3173 scrollTop: scrollTop 3174 }; 3175 } 3176 3177 function getWindowScrollBarX(element) { 3178 // If <html> has a CSS width greater than the viewport, then this will be 3179 // incorrect for RTL. 3180 // Popper 1 is broken in this case and never had a bug report so let's assume 3181 // it's not an issue. I don't think anyone ever specifies width on <html> 3182 // anyway. 3183 // Browsers where the left scrollbar doesn't cause an issue report `0` for 3184 // this (e.g. Edge 2019, IE11, Safari) 3185 return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft; 3186 } 3187 3188 function getViewportRect(element) { 3189 var win = getWindow(element); 3190 var html = getDocumentElement(element); 3191 var visualViewport = win.visualViewport; 3192 var width = html.clientWidth; 3193 var height = html.clientHeight; 3194 var x = 0; 3195 var y = 0; // NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper 3196 // can be obscured underneath it. 3197 // Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even 3198 // if it isn't open, so if this isn't available, the popper will be detected 3199 // to overflow the bottom of the screen too early. 3200 3201 if (visualViewport) {
vendor: 5,294 bytes, lines 3202-3342
3202 width = visualViewport.width; 3203 height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently) 3204 // In Chrome, it returns a value very close to 0 (+/-) but contains rounding 3205 // errors due to floating point numbers, so we need to check precision. 3206 // Safari returns a number <= 0, usually < -1 when pinch-zoomed 3207 // Feature detection fails in mobile emulation mode in Chrome. 3208 // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) < 3209 // 0.001 3210 // Fallback here: "Not Safari" userAgent 3211 3212 if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) { 3213 x = visualViewport.offsetLeft; 3214 y = visualViewport.offsetTop; 3215 } 3216 } 3217 3218 return { 3219 width: width, 3220 height: height, 3221 x: x + getWindowScrollBarX(element), 3222 y: y 3223 }; 3224 } 3225 3226 // of the `<html>` and `<body>` rect bounds if horizontally scrollable 3227 3228 function getDocumentRect(element) { 3229 var _element$ownerDocumen; 3230 3231 var html = getDocumentElement(element); 3232 var winScroll = getWindowScroll(element); 3233 var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body; 3234 var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0); 3235 var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0); 3236 var x = -winScroll.scrollLeft + getWindowScrollBarX(element); 3237 var y = -winScroll.scrollTop; 3238 3239 if (getComputedStyle$1(body || html).direction === 'rtl') { 3240 x += max(html.clientWidth, body ? body.clientWidth : 0) - width; 3241 } 3242 3243 return { 3244 width: width, 3245 height: height, 3246 x: x, 3247 y: y 3248 }; 3249 } 3250 3251 function isScrollParent(element) { 3252 // Firefox wants us to check `-x` and `-y` variations as well 3253 var _getComputedStyle = getComputedStyle$1(element), 3254 overflow = _getComputedStyle.overflow, 3255 overflowX = _getComputedStyle.overflowX, 3256 overflowY = _getComputedStyle.overflowY; 3257 3258 return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); 3259 } 3260 3261 function getScrollParent(node) { 3262 if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) { 3263 // $FlowFixMe[incompatible-return]: assume body is always available 3264 return node.ownerDocument.body; 3265 } 3266 3267 if (isHTMLElement(node) && isScrollParent(node)) { 3268 return node; 3269 } 3270 3271 return getScrollParent(getParentNode(node)); 3272 } 3273 3274 /* 3275 given a DOM element, return the list of all scroll parents, up the list of ancesors 3276 until we get to the top window object. This list is what we attach scroll listeners 3277 to, because if any of these parent elements scroll, we'll need to re-calculate the 3278 reference element's position. 3279 */ 3280 3281 function listScrollParents(element, list) { 3282 var _element$ownerDocumen; 3283 3284 if (list === void 0) { 3285 list = []; 3286 } 3287 3288 var scrollParent = getScrollParent(element); 3289 var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body); 3290 var win = getWindow(scrollParent); 3291 var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent; 3292 var updatedList = list.concat(target); 3293 return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here 3294 updatedList.concat(listScrollParents(getParentNode(target))); 3295 } 3296 3297 function rectToClientRect(rect) { 3298 return Object.assign({}, rect, { 3299 left: rect.x, 3300 top: rect.y, 3301 right: rect.x + rect.width, 3302 bottom: rect.y + rect.height 3303 }); 3304 } 3305 3306 function getInnerBoundingClientRect(element) { 3307 var rect = getBoundingClientRect(element); 3308 rect.top = rect.top + element.clientTop; 3309 rect.left = rect.left + element.clientLeft; 3310 rect.bottom = rect.top + element.clientHeight; 3311 rect.right = rect.left + element.clientWidth; 3312 rect.width = element.clientWidth; 3313 rect.height = element.clientHeight; 3314 rect.x = rect.left; 3315 rect.y = rect.top; 3316 return rect; 3317 } 3318 3319 function getClientRectFromMixedType(element, clippingParent) { 3320 return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element))); 3321 } // A "clipping parent" is an overflowable container with the characteristic of 3322 // clipping (or hiding) overflowing elements with a position different from 3323 // `initial` 3324 3325 3326 function getClippingParents(element) { 3327 var clippingParents = listScrollParents(getParentNode(element)); 3328 var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0; 3329 var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element; 3330 3331 if (!isElement(clipperElement)) { 3332 return []; 3333 } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414 3334 3335 3336 return clippingParents.filter(function (clippingParent) { 3337 return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body'; 3338 }); 3339 } // Gets the maximum area that the element is visible in due to any number of 3340 // clipping parents 3341 3342
vendor: 4,990 bytes, lines 3343-3470
3343 function getClippingRect(element, boundary, rootBoundary) { 3344 var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary); 3345 var clippingParents = [].concat(mainClippingParents, [rootBoundary]); 3346 var firstClippingParent = clippingParents[0]; 3347 var clippingRect = clippingParents.reduce(function (accRect, clippingParent) { 3348 var rect = getClientRectFromMixedType(element, clippingParent); 3349 accRect.top = max(rect.top, accRect.top); 3350 accRect.right = min(rect.right, accRect.right); 3351 accRect.bottom = min(rect.bottom, accRect.bottom); 3352 accRect.left = max(rect.left, accRect.left); 3353 return accRect; 3354 }, getClientRectFromMixedType(element, firstClippingParent)); 3355 clippingRect.width = clippingRect.right - clippingRect.left; 3356 clippingRect.height = clippingRect.bottom - clippingRect.top; 3357 clippingRect.x = clippingRect.left; 3358 clippingRect.y = clippingRect.top; 3359 return clippingRect; 3360 } 3361 3362 function computeOffsets(_ref) { 3363 var reference = _ref.reference, 3364 element = _ref.element, 3365 placement = _ref.placement; 3366 var basePlacement = placement ? getBasePlacement(placement) : null; 3367 var variation = placement ? getVariation(placement) : null; 3368 var commonX = reference.x + reference.width / 2 - element.width / 2; 3369 var commonY = reference.y + reference.height / 2 - element.height / 2; 3370 var offsets; 3371 3372 switch (basePlacement) { 3373 case top: 3374 offsets = { 3375 x: commonX, 3376 y: reference.y - element.height 3377 }; 3378 break; 3379 3380 case bottom: 3381 offsets = { 3382 x: commonX, 3383 y: reference.y + reference.height 3384 }; 3385 break; 3386 3387 case right: 3388 offsets = { 3389 x: reference.x + reference.width, 3390 y: commonY 3391 }; 3392 break; 3393 3394 case left: 3395 offsets = { 3396 x: reference.x - element.width, 3397 y: commonY 3398 }; 3399 break; 3400 3401 default: 3402 offsets = { 3403 x: reference.x, 3404 y: reference.y 3405 }; 3406 } 3407 3408 var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null; 3409 3410 if (mainAxis != null) { 3411 var len = mainAxis === 'y' ? 'height' : 'width'; 3412 3413 switch (variation) { 3414 case start: 3415 offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2); 3416 break; 3417 3418 case end: 3419 offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2); 3420 break; 3421 } 3422 } 3423 3424 return offsets; 3425 } 3426 3427 function detectOverflow(state, options) { 3428 if (options === void 0) { 3429 options = {}; 3430 } 3431 3432 var _options = options, 3433 _options$placement = _options.placement, 3434 placement = _options$placement === void 0 ? state.placement : _options$placement, 3435 _options$boundary = _options.boundary, 3436 boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, 3437 _options$rootBoundary = _options.rootBoundary, 3438 rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, 3439 _options$elementConte = _options.elementContext, 3440 elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, 3441 _options$altBoundary = _options.altBoundary, 3442 altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, 3443 _options$padding = _options.padding, 3444 padding = _options$padding === void 0 ? 0 : _options$padding; 3445 var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); 3446 var altContext = elementContext === popper ? reference : popper; 3447 var popperRect = state.rects.popper; 3448 var element = state.elements[altBoundary ? altContext : elementContext]; 3449 var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary); 3450 var referenceClientRect = getBoundingClientRect(state.elements.reference); 3451 var popperOffsets = computeOffsets({ 3452 reference: referenceClientRect, 3453 element: popperRect, 3454 strategy: 'absolute', 3455 placement: placement 3456 }); 3457 var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets)); 3458 var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect 3459 // 0 or negative = within the clipping rect 3460 3461 var overflowOffsets = { 3462 top: clippingClientRect.top - elementClientRect.top + paddingObject.top, 3463 bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom, 3464 left: clippingClientRect.left - elementClientRect.left + paddingObject.left, 3465 right: elementClientRect.right - clippingClientRect.right + paddingObject.right 3466 }; 3467 var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element 3468 3469 if (elementContext === popper && offsetData) { 3470 var offset = offsetData[placement];
vendor: 4,221 bytes, lines 3471-3578
3471 Object.keys(overflowOffsets).forEach(function (key) { 3472 var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1; 3473 var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x'; 3474 overflowOffsets[key] += offset[axis] * multiply; 3475 }); 3476 } 3477 3478 return overflowOffsets; 3479 } 3480 3481 function computeAutoPlacement(state, options) { 3482 if (options === void 0) { 3483 options = {}; 3484 } 3485 3486 var _options = options, 3487 placement = _options.placement, 3488 boundary = _options.boundary, 3489 rootBoundary = _options.rootBoundary, 3490 padding = _options.padding, 3491 flipVariations = _options.flipVariations, 3492 _options$allowedAutoP = _options.allowedAutoPlacements, 3493 allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP; 3494 var variation = getVariation(placement); 3495 var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) { 3496 return getVariation(placement) === variation; 3497 }) : basePlacements; 3498 var allowedPlacements = placements$1.filter(function (placement) { 3499 return allowedAutoPlacements.indexOf(placement) >= 0; 3500 }); 3501 3502 if (allowedPlacements.length === 0) { 3503 allowedPlacements = placements$1; 3504 } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions... 3505 3506 3507 var overflows = allowedPlacements.reduce(function (acc, placement) { 3508 acc[placement] = detectOverflow(state, { 3509 placement: placement, 3510 boundary: boundary, 3511 rootBoundary: rootBoundary, 3512 padding: padding 3513 })[getBasePlacement(placement)]; 3514 return acc; 3515 }, {}); 3516 return Object.keys(overflows).sort(function (a, b) { 3517 return overflows[a] - overflows[b]; 3518 }); 3519 } 3520 3521 function getExpandedFallbackPlacements(placement) { 3522 if (getBasePlacement(placement) === auto) { 3523 return []; 3524 } 3525 3526 var oppositePlacement = getOppositePlacement(placement); 3527 return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)]; 3528 } 3529 3530 function flip(_ref) { 3531 var state = _ref.state, 3532 options = _ref.options, 3533 name = _ref.name; 3534 3535 if (state.modifiersData[name]._skip) { 3536 return; 3537 } 3538 3539 var _options$mainAxis = options.mainAxis, 3540 checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, 3541 _options$altAxis = options.altAxis, 3542 checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, 3543 specifiedFallbackPlacements = options.fallbackPlacements, 3544 padding = options.padding, 3545 boundary = options.boundary, 3546 rootBoundary = options.rootBoundary, 3547 altBoundary = options.altBoundary, 3548 _options$flipVariatio = options.flipVariations, 3549 flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, 3550 allowedAutoPlacements = options.allowedAutoPlacements; 3551 var preferredPlacement = state.options.placement; 3552 var basePlacement = getBasePlacement(preferredPlacement); 3553 var isBasePlacement = basePlacement === preferredPlacement; 3554 var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement)); 3555 var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) { 3556 return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, { 3557 placement: placement, 3558 boundary: boundary, 3559 rootBoundary: rootBoundary, 3560 padding: padding, 3561 flipVariations: flipVariations, 3562 allowedAutoPlacements: allowedAutoPlacements 3563 }) : placement); 3564 }, []); 3565 var referenceRect = state.rects.reference; 3566 var popperRect = state.rects.popper; 3567 var checksMap = new Map(); 3568 var makeFallbackChecks = true; 3569 var firstFittingPlacement = placements[0]; 3570 3571 for (var i = 0; i < placements.length; i++) { 3572 var placement = placements[i]; 3573 3574 var _basePlacement = getBasePlacement(placement); 3575 3576 var isStartVariation = getVariation(placement) === start; 3577 var isVertical = [top, bottom].indexOf(_basePlacement) >= 0; 3578 var len = isVertical ? 'width' : 'height';
vendor: 8,900 bytes, lines 3579-3868
3579 var overflow = detectOverflow(state, { 3580 placement: placement, 3581 boundary: boundary, 3582 rootBoundary: rootBoundary, 3583 altBoundary: altBoundary, 3584 padding: padding 3585 }); 3586 var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top; 3587 3588 if (referenceRect[len] > popperRect[len]) { 3589 mainVariationSide = getOppositePlacement(mainVariationSide); 3590 } 3591 3592 var altVariationSide = getOppositePlacement(mainVariationSide); 3593 var checks = []; 3594 3595 if (checkMainAxis) { 3596 checks.push(overflow[_basePlacement] <= 0); 3597 } 3598 3599 if (checkAltAxis) { 3600 checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0); 3601 } 3602 3603 if (checks.every(function (check) { 3604 return check; 3605 })) { 3606 firstFittingPlacement = placement; 3607 makeFallbackChecks = false; 3608 break; 3609 } 3610 3611 checksMap.set(placement, checks); 3612 } 3613 3614 if (makeFallbackChecks) { 3615 // `2` may be desired in some cases – research later 3616 var numberOfChecks = flipVariations ? 3 : 1; 3617 3618 var _loop = function _loop(_i) { 3619 var fittingPlacement = placements.find(function (placement) { 3620 var checks = checksMap.get(placement); 3621 3622 if (checks) { 3623 return checks.slice(0, _i).every(function (check) { 3624 return check; 3625 }); 3626 } 3627 }); 3628 3629 if (fittingPlacement) { 3630 firstFittingPlacement = fittingPlacement; 3631 return "break"; 3632 } 3633 }; 3634 3635 for (var _i = numberOfChecks; _i > 0; _i--) { 3636 var _ret = _loop(_i); 3637 3638 if (_ret === "break") break; 3639 } 3640 } 3641 3642 if (state.placement !== firstFittingPlacement) { 3643 state.modifiersData[name]._skip = true; 3644 state.placement = firstFittingPlacement; 3645 state.reset = true; 3646 } 3647 } // eslint-disable-next-line import/no-unused-modules 3648 3649 3650 var flip$1 = { 3651 name: 'flip', 3652 enabled: true, 3653 phase: 'main', 3654 fn: flip, 3655 requiresIfExists: ['offset'], 3656 data: { 3657 _skip: false 3658 } 3659 }; 3660 3661 function getSideOffsets(overflow, rect, preventedOffsets) { 3662 if (preventedOffsets === void 0) { 3663 preventedOffsets = { 3664 x: 0, 3665 y: 0 3666 }; 3667 } 3668 3669 return { 3670 top: overflow.top - rect.height - preventedOffsets.y, 3671 right: overflow.right - rect.width + preventedOffsets.x, 3672 bottom: overflow.bottom - rect.height + preventedOffsets.y, 3673 left: overflow.left - rect.width - preventedOffsets.x 3674 }; 3675 } 3676 3677 function isAnySideFullyClipped(overflow) { 3678 return [top, right, bottom, left].some(function (side) { 3679 return overflow[side] >= 0; 3680 }); 3681 } 3682 3683 function hide(_ref) { 3684 var state = _ref.state, 3685 name = _ref.name; 3686 var referenceRect = state.rects.reference; 3687 var popperRect = state.rects.popper; 3688 var preventedOffsets = state.modifiersData.preventOverflow; 3689 var referenceOverflow = detectOverflow(state, { 3690 elementContext: 'reference' 3691 }); 3692 var popperAltOverflow = detectOverflow(state, { 3693 altBoundary: true 3694 }); 3695 var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect); 3696 var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets); 3697 var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets); 3698 var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets); 3699 state.modifiersData[name] = { 3700 referenceClippingOffsets: referenceClippingOffsets, 3701 popperEscapeOffsets: popperEscapeOffsets, 3702 isReferenceHidden: isReferenceHidden, 3703 hasPopperEscaped: hasPopperEscaped 3704 }; 3705 state.attributes.popper = Object.assign({}, state.attributes.popper, { 3706 'data-popper-reference-hidden': isReferenceHidden, 3707 'data-popper-escaped': hasPopperEscaped 3708 }); 3709 } // eslint-disable-next-line import/no-unused-modules 3710 3711 3712 var hide$1 = { 3713 name: 'hide', 3714 enabled: true, 3715 phase: 'main', 3716 requiresIfExists: ['preventOverflow'], 3717 fn: hide 3718 }; 3719 3720 function distanceAndSkiddingToXY(placement, rects, offset) { 3721 var basePlacement = getBasePlacement(placement); 3722 var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1; 3723 3724 var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, { 3725 placement: placement 3726 })) : offset, 3727 skidding = _ref[0], 3728 distance = _ref[1]; 3729 3730 skidding = skidding || 0; 3731 distance = (distance || 0) * invertDistance; 3732 return [left, right].indexOf(basePlacement) >= 0 ? { 3733 x: distance, 3734 y: skidding 3735 } : { 3736 x: skidding, 3737 y: distance 3738 }; 3739 } 3740 3741 function offset(_ref2) { 3742 var state = _ref2.state, 3743 options = _ref2.options, 3744 name = _ref2.name; 3745 var _options$offset = options.offset, 3746 offset = _options$offset === void 0 ? [0, 0] : _options$offset; 3747 var data = placements.reduce(function (acc, placement) { 3748 acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset); 3749 return acc; 3750 }, {}); 3751 var _data$state$placement = data[state.placement], 3752 x = _data$state$placement.x, 3753 y = _data$state$placement.y; 3754 3755 if (state.modifiersData.popperOffsets != null) { 3756 state.modifiersData.popperOffsets.x += x; 3757 state.modifiersData.popperOffsets.y += y; 3758 } 3759 3760 state.modifiersData[name] = data; 3761 } // eslint-disable-next-line import/no-unused-modules 3762 3763 3764 var offset$1 = { 3765 name: 'offset', 3766 enabled: true, 3767 phase: 'main', 3768 requires: ['popperOffsets'], 3769 fn: offset 3770 }; 3771 3772 function popperOffsets(_ref) { 3773 var state = _ref.state, 3774 name = _ref.name; 3775 // Offsets are the actual position the popper needs to have to be 3776 // properly positioned near its reference element 3777 // This is the most basic placement, and will be adjusted by 3778 // the modifiers in the next step 3779 state.modifiersData[name] = computeOffsets({ 3780 reference: state.rects.reference, 3781 element: state.rects.popper, 3782 strategy: 'absolute', 3783 placement: state.placement 3784 }); 3785 } // eslint-disable-next-line import/no-unused-modules 3786 3787 3788 var popperOffsets$1 = { 3789 name: 'popperOffsets', 3790 enabled: true, 3791 phase: 'read', 3792 fn: popperOffsets, 3793 data: {} 3794 }; 3795 3796 function getAltAxis(axis) { 3797 return axis === 'x' ? 'y' : 'x'; 3798 } 3799 3800 function preventOverflow(_ref) { 3801 var state = _ref.state, 3802 options = _ref.options, 3803 name = _ref.name; 3804 var _options$mainAxis = options.mainAxis, 3805 checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, 3806 _options$altAxis = options.altAxis, 3807 checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, 3808 boundary = options.boundary, 3809 rootBoundary = options.rootBoundary, 3810 altBoundary = options.altBoundary, 3811 padding = options.padding, 3812 _options$tether = options.tether, 3813 tether = _options$tether === void 0 ? true : _options$tether, 3814 _options$tetherOffset = options.tetherOffset, 3815 tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset; 3816 var overflow = detectOverflow(state, { 3817 boundary: boundary, 3818 rootBoundary: rootBoundary, 3819 padding: padding, 3820 altBoundary: altBoundary 3821 }); 3822 var basePlacement = getBasePlacement(state.placement); 3823 var variation = getVariation(state.placement); 3824 var isBasePlacement = !variation; 3825 var mainAxis = getMainAxisFromPlacement(basePlacement); 3826 var altAxis = getAltAxis(mainAxis); 3827 var popperOffsets = state.modifiersData.popperOffsets; 3828 var referenceRect = state.rects.reference; 3829 var popperRect = state.rects.popper; 3830 var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, { 3831 placement: state.placement 3832 })) : tetherOffset; 3833 var normalizedTetherOffsetValue = typeof tetherOffsetValue === 'number' ? { 3834 mainAxis: tetherOffsetValue, 3835 altAxis: tetherOffsetValue 3836 } : Object.assign({ 3837 mainAxis: 0, 3838 altAxis: 0 3839 }, tetherOffsetValue); 3840 var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null; 3841 var data = { 3842 x: 0, 3843 y: 0 3844 }; 3845 3846 if (!popperOffsets) { 3847 return; 3848 } 3849 3850 if (checkMainAxis) { 3851 var _offsetModifierState$; 3852 3853 var mainSide = mainAxis === 'y' ? top : left; 3854 var altSide = mainAxis === 'y' ? bottom : right; 3855 var len = mainAxis === 'y' ? 'height' : 'width'; 3856 var offset = popperOffsets[mainAxis]; 3857 var min$1 = offset + overflow[mainSide]; 3858 var max$1 = offset - overflow[altSide]; 3859 var additive = tether ? -popperRect[len] / 2 : 0; 3860 var minLen = variation === start ? referenceRect[len] : popperRect[len]; 3861 var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go 3862 // outside the reference bounds 3863 3864 var arrowElement = state.elements.arrow; 3865 var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : { 3866 width: 0, 3867 height: 0 3868 };
vendor: 4,138 bytes, lines 3869-3957
3869 var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject(); 3870 var arrowPaddingMin = arrowPaddingObject[mainSide]; 3871 var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want 3872 // to include its full size in the calculation. If the reference is small 3873 // and near the edge of a boundary, the popper can overflow even if the 3874 // reference is not overflowing as well (e.g. virtual elements with no 3875 // width or height) 3876 3877 var arrowLen = within(0, referenceRect[len], arrowRect[len]); 3878 var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis; 3879 var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis; 3880 var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow); 3881 var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0; 3882 var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0; 3883 var tetherMin = offset + minOffset - offsetModifierValue - clientOffset; 3884 var tetherMax = offset + maxOffset - offsetModifierValue; 3885 var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset, tether ? max(max$1, tetherMax) : max$1); 3886 popperOffsets[mainAxis] = preventedOffset; 3887 data[mainAxis] = preventedOffset - offset; 3888 } 3889 3890 if (checkAltAxis) { 3891 var _offsetModifierState$2; 3892 3893 var _mainSide = mainAxis === 'x' ? top : left; 3894 3895 var _altSide = mainAxis === 'x' ? bottom : right; 3896 3897 var _offset = popperOffsets[altAxis]; 3898 3899 var _len = altAxis === 'y' ? 'height' : 'width'; 3900 3901 var _min = _offset + overflow[_mainSide]; 3902 3903 var _max = _offset - overflow[_altSide]; 3904 3905 var isOriginSide = [top, left].indexOf(basePlacement) !== -1; 3906 3907 var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0; 3908 3909 var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis; 3910 3911 var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max; 3912 3913 var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max); 3914 3915 popperOffsets[altAxis] = _preventedOffset; 3916 data[altAxis] = _preventedOffset - _offset; 3917 } 3918 3919 state.modifiersData[name] = data; 3920 } // eslint-disable-next-line import/no-unused-modules 3921 3922 3923 var preventOverflow$1 = { 3924 name: 'preventOverflow', 3925 enabled: true, 3926 phase: 'main', 3927 fn: preventOverflow, 3928 requiresIfExists: ['offset'] 3929 }; 3930 3931 function getHTMLElementScroll(element) { 3932 return { 3933 scrollLeft: element.scrollLeft, 3934 scrollTop: element.scrollTop 3935 }; 3936 } 3937 3938 function getNodeScroll(node) { 3939 if (node === getWindow(node) || !isHTMLElement(node)) { 3940 return getWindowScroll(node); 3941 } else { 3942 return getHTMLElementScroll(node); 3943 } 3944 } 3945 3946 function isElementScaled(element) { 3947 var rect = element.getBoundingClientRect(); 3948 var scaleX = round(rect.width) / element.offsetWidth || 1; 3949 var scaleY = round(rect.height) / element.offsetHeight || 1; 3950 return scaleX !== 1 || scaleY !== 1; 3951 } // Returns the composite rect of an element relative to its offsetParent. 3952 // Composite means it takes into account transforms as well as layout. 3953 3954 3955 function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) { 3956 if (isFixed === void 0) { 3957 isFixed = false;
vendor: 9,295 bytes, lines 3958-4229
3958 } 3959 3960 var isOffsetParentAnElement = isHTMLElement(offsetParent); 3961 var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent); 3962 var documentElement = getDocumentElement(offsetParent); 3963 var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled); 3964 var scroll = { 3965 scrollLeft: 0, 3966 scrollTop: 0 3967 }; 3968 var offsets = { 3969 x: 0, 3970 y: 0 3971 }; 3972 3973 if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) { 3974 if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078 3975 isScrollParent(documentElement)) { 3976 scroll = getNodeScroll(offsetParent); 3977 } 3978 3979 if (isHTMLElement(offsetParent)) { 3980 offsets = getBoundingClientRect(offsetParent, true); 3981 offsets.x += offsetParent.clientLeft; 3982 offsets.y += offsetParent.clientTop; 3983 } else if (documentElement) { 3984 offsets.x = getWindowScrollBarX(documentElement); 3985 } 3986 } 3987 3988 return { 3989 x: rect.left + scroll.scrollLeft - offsets.x, 3990 y: rect.top + scroll.scrollTop - offsets.y, 3991 width: rect.width, 3992 height: rect.height 3993 }; 3994 } 3995 3996 function order(modifiers) { 3997 var map = new Map(); 3998 var visited = new Set(); 3999 var result = []; 4000 modifiers.forEach(function (modifier) { 4001 map.set(modifier.name, modifier); 4002 }); // On visiting object, check for its dependencies and visit them recursively 4003 4004 function sort(modifier) { 4005 visited.add(modifier.name); 4006 var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []); 4007 requires.forEach(function (dep) { 4008 if (!visited.has(dep)) { 4009 var depModifier = map.get(dep); 4010 4011 if (depModifier) { 4012 sort(depModifier); 4013 } 4014 } 4015 }); 4016 result.push(modifier); 4017 } 4018 4019 modifiers.forEach(function (modifier) { 4020 if (!visited.has(modifier.name)) { 4021 // check for visited object 4022 sort(modifier); 4023 } 4024 }); 4025 return result; 4026 } 4027 4028 function orderModifiers(modifiers) { 4029 // order based on dependencies 4030 var orderedModifiers = order(modifiers); // order based on phase 4031 4032 return modifierPhases.reduce(function (acc, phase) { 4033 return acc.concat(orderedModifiers.filter(function (modifier) { 4034 return modifier.phase === phase; 4035 })); 4036 }, []); 4037 } 4038 4039 function debounce(fn) { 4040 var pending; 4041 return function () { 4042 if (!pending) { 4043 pending = new Promise(function (resolve) { 4044 Promise.resolve().then(function () { 4045 pending = undefined; 4046 resolve(fn()); 4047 }); 4048 }); 4049 } 4050 4051 return pending; 4052 }; 4053 } 4054 4055 function mergeByName(modifiers) { 4056 var merged = modifiers.reduce(function (merged, current) { 4057 var existing = merged[current.name]; 4058 merged[current.name] = existing ? Object.assign({}, existing, current, { 4059 options: Object.assign({}, existing.options, current.options), 4060 data: Object.assign({}, existing.data, current.data) 4061 }) : current; 4062 return merged; 4063 }, {}); // IE11 does not support Object.values 4064 4065 return Object.keys(merged).map(function (key) { 4066 return merged[key]; 4067 }); 4068 } 4069 4070 var DEFAULT_OPTIONS = { 4071 placement: 'bottom', 4072 modifiers: [], 4073 strategy: 'absolute' 4074 }; 4075 4076 function areValidElements() { 4077 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 4078 args[_key] = arguments[_key]; 4079 } 4080 4081 return !args.some(function (element) { 4082 return !(element && typeof element.getBoundingClientRect === 'function'); 4083 }); 4084 } 4085 4086 function popperGenerator(generatorOptions) { 4087 if (generatorOptions === void 0) { 4088 generatorOptions = {}; 4089 } 4090 4091 var _generatorOptions = generatorOptions, 4092 _generatorOptions$def = _generatorOptions.defaultModifiers, 4093 defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, 4094 _generatorOptions$def2 = _generatorOptions.defaultOptions, 4095 defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2; 4096 return function createPopper(reference, popper, options) { 4097 if (options === void 0) { 4098 options = defaultOptions; 4099 } 4100 4101 var state = { 4102 placement: 'bottom', 4103 orderedModifiers: [], 4104 options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions), 4105 modifiersData: {}, 4106 elements: { 4107 reference: reference, 4108 popper: popper 4109 }, 4110 attributes: {}, 4111 styles: {} 4112 }; 4113 var effectCleanupFns = []; 4114 var isDestroyed = false; 4115 var instance = { 4116 state: state, 4117 setOptions: function setOptions(setOptionsAction) { 4118 var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction; 4119 cleanupModifierEffects(); 4120 state.options = Object.assign({}, defaultOptions, state.options, options); 4121 state.scrollParents = { 4122 reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [], 4123 popper: listScrollParents(popper) 4124 }; // Orders the modifiers based on their dependencies and `phase` 4125 // properties 4126 4127 var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers 4128 4129 state.orderedModifiers = orderedModifiers.filter(function (m) { 4130 return m.enabled; 4131 }); // Validate the provided modifiers so that the consumer will get warned 4132 4133 runModifierEffects(); 4134 return instance.update(); 4135 }, 4136 // Sync update – it will always be executed, even if not necessary. This 4137 // is useful for low frequency updates where sync behavior simplifies the 4138 // logic. 4139 // For high frequency updates (e.g. `resize` and `scroll` events), always 4140 // prefer the async Popper#update method 4141 forceUpdate: function forceUpdate() { 4142 if (isDestroyed) { 4143 return; 4144 } 4145 4146 var _state$elements = state.elements, 4147 reference = _state$elements.reference, 4148 popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements 4149 // anymore 4150 4151 if (!areValidElements(reference, popper)) { 4152 4153 return; 4154 } // Store the reference and popper rects to be read by modifiers 4155 4156 4157 state.rects = { 4158 reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'), 4159 popper: getLayoutRect(popper) 4160 }; // Modifiers have the ability to reset the current update cycle. The 4161 // most common use case for this is the `flip` modifier changing the 4162 // placement, which then needs to re-run all the modifiers, because the 4163 // logic was previously ran for the previous placement and is therefore 4164 // stale/incorrect 4165 4166 state.reset = false; 4167 state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier 4168 // is filled with the initial data specified by the modifier. This means 4169 // it doesn't persist and is fresh on each update. 4170 // To ensure persistent data, use `${name}#persistent` 4171 4172 state.orderedModifiers.forEach(function (modifier) { 4173 return state.modifiersData[modifier.name] = Object.assign({}, modifier.data); 4174 }); 4175 4176 for (var index = 0; index < state.orderedModifiers.length; index++) { 4177 4178 if (state.reset === true) { 4179 state.reset = false; 4180 index = -1; 4181 continue; 4182 } 4183 4184 var _state$orderedModifie = state.orderedModifiers[index], 4185 fn = _state$orderedModifie.fn, 4186 _state$orderedModifie2 = _state$orderedModifie.options, 4187 _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, 4188 name = _state$orderedModifie.name; 4189 4190 if (typeof fn === 'function') { 4191 state = fn({ 4192 state: state, 4193 options: _options, 4194 name: name, 4195 instance: instance 4196 }) || state; 4197 } 4198 } 4199 }, 4200 // Async and optimistically optimized update – it will not be executed if 4201 // not necessary (debounced to run at most once-per-tick) 4202 update: debounce(function () { 4203 return new Promise(function (resolve) { 4204 instance.forceUpdate(); 4205 resolve(state); 4206 }); 4207 }), 4208 destroy: function destroy() { 4209 cleanupModifierEffects(); 4210 isDestroyed = true; 4211 } 4212 }; 4213 4214 if (!areValidElements(reference, popper)) { 4215 4216 return instance; 4217 } 4218 4219 instance.setOptions(options).then(function (state) { 4220 if (!isDestroyed && options.onFirstUpdate) { 4221 options.onFirstUpdate(state); 4222 } 4223 }); // Modifiers have the ability to execute arbitrary code before the first 4224 // update cycle runs. They will be executed in the same order as the update 4225 // cycle. This is useful when a modifier adds some persistent data that 4226 // other modifiers need to use, but the modifier is run after the dependent 4227 // one. 4228 4229 function runModifierEffects() {
4230 state.orderedModifiers.forEach(function (_ref3) { 4231 var name = _ref3.name, 4232 _ref3$options = _ref3.options, 4233 options = _ref3$options === void 0 ? {} : _ref3$options, 4234 effect = _ref3.effect; 4235 4236 if (typeof effect === 'function') { 4237 var cleanupFn = effect({ 4238 state: state, 4239 name: name, 4240 instance: instance, 4241 options: options 4242 }); 4243 4244 var noopFn = function noopFn() {}; 4245 4246 effectCleanupFns.push(cleanupFn || noopFn); 4247 } 4248 }); 4249 } 4250 4251 function cleanupModifierEffects() { 4252 effectCleanupFns.forEach(function (fn) { 4253 return fn(); 4254 }); 4255 effectCleanupFns = []; 4256 } 4257 4258 return instance; 4259 }; 4260 } 4261 var createPopper$2 = /*#__PURE__*/popperGenerator(); // eslint-disable-next-line import/no-unused-modules 4262 4263 var defaultModifiers$1 = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1]; 4264 var createPopper$1 = /*#__PURE__*/popperGenerator({ 4265 defaultModifiers: defaultModifiers$1 4266 }); // eslint-disable-next-line import/no-unused-modules 4267 4268 var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1]; 4269 var createPopper = /*#__PURE__*/popperGenerator({ 4270 defaultModifiers: defaultModifiers 4271 }); // eslint-disable-next-line import/no-unused-modules 4272 4273 var lib = /*#__PURE__*/Object.freeze({ 4274 __proto__: null, 4275 popperGenerator: popperGenerator, 4276 detectOverflow: detectOverflow, 4277 createPopperBase: createPopper$2, 4278 createPopper: createPopper, 4279 createPopperLite: createPopper$1, 4280 top: top, 4281 bottom: bottom, 4282 right: right, 4283 left: left, 4284 auto: auto, 4285 basePlacements: basePlacements, 4286 start: start, 4287 end: end, 4288 clippingParents: clippingParents, 4289 viewport: viewport, 4290 popper: popper, 4291 reference: reference, 4292 variationPlacements: variationPlacements, 4293 placements: placements, 4294 beforeRead: beforeRead, 4295 read: read, 4296 afterRead: afterRead, 4297 beforeMain: beforeMain, 4298 main: main, 4299 afterMain: afterMain, 4300 beforeWrite: beforeWrite, 4301 write: write, 4302 afterWrite: afterWrite, 4303 modifierPhases: modifierPhases, 4304 applyStyles: applyStyles$1, 4305 arrow: arrow$1, 4306 computeStyles: computeStyles$1, 4307 eventListeners: eventListeners, 4308 flip: flip$1, 4309 hide: hide$1, 4310 offset: offset$1, 4311 popperOffsets: popperOffsets$1, 4312 preventOverflow: preventOverflow$1 4313 }); 4314 4315 var require$$0 = /*@__PURE__*/getAugmentedNamespace(lib); 4316 4317 /*! 4318 * Bootstrap dropdown.js v5.1.3 (https://getbootstrap.com/) 4319 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 4320 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4321 */ 4322 4323 (function (module, exports) { 4324 (function (global, factory) { 4325 module.exports = factory(require$$0, eventHandler.exports, manipulator.exports, selectorEngine.exports, baseComponent.exports) ; 4326 })(commonjsGlobal, (function (Popper, EventHandler, Manipulator, SelectorEngine, BaseComponent) { 4327 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 4328 4329 function _interopNamespace(e) { 4330 if (e && e.__esModule) return e; 4331 const n = Object.create(null); 4332 if (e) { 4333 for (const k in e) { 4334 if (k !== 'default') { 4335 const d = Object.getOwnPropertyDescriptor(e, k); 4336 Object.defineProperty(n, k, d.get ? d : { 4337 enumerable: true, 4338 get: () => e[k] 4339 }); 4340 } 4341 } 4342 } 4343 n.default = e; 4344 return Object.freeze(n); 4345 } 4346 4347 const Popper__namespace = /*#__PURE__*/_interopNamespace(Popper); 4348 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 4349 const Manipulator__default = /*#__PURE__*/_interopDefaultLegacy(Manipulator); 4350 const SelectorEngine__default = /*#__PURE__*/_interopDefaultLegacy(SelectorEngine); 4351 const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); 4352 4353 /** 4354 * -------------------------------------------------------------------------- 4355 * Bootstrap (v5.1.3): util/index.js 4356 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4357 * -------------------------------------------------------------------------- 4358 */ 4359 4360 const toType = obj => { 4361 if (obj === null || obj === undefined) { 4362 return `${obj}`; 4363 } 4364 4365 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 4366 }; 4367 4368 const getSelector = element => { 4369 let selector = element.getAttribute('data-bs-target'); 4370 4371 if (!selector || selector === '#') { 4372 let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes, 4373 // so everything starting with `#` or `.`. If a "real" URL is used as the selector, 4374 // `document.querySelector` will rightfully complain it is invali
4374d. 4375 // See https://github.com/twbs/bootstrap/issues/32273 4376 4377 if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) { 4378 return null; 4379 } // Just in case some CMS puts out a full URL with the anchor appended 4380 4381 4382 if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) { 4383 hrefAttr = `#${hrefAttr.split('#')[1]}`; 4384 } 4385 4386 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null; 4387 } 4388 4389 return selector; 4390 }; 4391 4392 const getElementFromSelector = element => { 4393 const selector = getSelector(element); 4394 return selector ? document.querySelector(selector) : null; 4395 }; 4396 4397 const isElement = obj => { 4398 if (!obj || typeof obj !== 'object') { 4399 return false; 4400 } 4401 4402 if (typeof obj.jquery !== 'undefined') { 4403 obj = obj[0]; 4404 } 4405 4406 return typeof obj.nodeType !== 'undefined'; 4407 }; 4408 4409 const getElement = obj => { 4410 if (isElement(obj)) { 4411 // it's a jQuery object or a node element 4412 return obj.jquery ? obj[0] : obj; 4413 } 4414 4415 if (typeof obj === 'string' && obj.length > 0) { 4416 return document.querySelector(obj); 4417 } 4418 4419 return null; 4420 }; 4421 4422 const typeCheckConfig = (componentName, config, configTypes) => { 4423 Object.keys(configTypes).forEach(property => { 4424 const expectedTypes = configTypes[property]; 4425 const value = config[property]; 4426 const valueType = value && isElement(value) ? 'element' : toType(value); 4427 4428 if (!new RegExp(expectedTypes).test(valueType)) { 4429 throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); 4430 } 4431 }); 4432 }; 4433 4434 const isVisible = element => { 4435 if (!isElement(element) || element.getClientRects().length === 0) { 4436 return false; 4437 } 4438 4439 return getComputedStyle(element).getPropertyValue('visibility') === 'visible'; 4440 }; 4441 4442 const isDisabled = element => { 4443 if (!element || element.nodeType !== Node.ELEMENT_NODE) { 4444 return true; 4445 } 4446 4447 if (element.classList.contains('disabled')) { 4448 return true; 4449 } 4450 4451 if (typeof element.disabled !== 'undefined') { 4452 return element.disabled; 4453 } 4454 4455 return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'; 4456 }; 4457 4458 const noop = () => {}; 4459 4460 const getjQuery = () => { 4461 const { 4462 jQuery 4463 } = window; 4464 4465 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 4466 return jQuery; 4467 } 4468 4469 return null; 4470 }; 4471 4472 const DOMContentLoadedCallbacks = []; 4473 4474 const onDOMContentLoaded = callback => { 4475 if (document.readyState === 'loading') { 4476 // add listener on the first call when the document is in loading state 4477 if (!DOMContentLoadedCallbacks.length) { 4478 document.addEventListener('DOMContentLoaded', () => { 4479 DOMContentLoadedCallbacks.forEach(callback => callback()); 4480 }); 4481 } 4482 4483 DOMContentLoadedCallbacks.push(callback); 4484 } else { 4485 callback(); 4486 } 4487 }; 4488 4489 const isRTL = () => document.documentElement.dir === 'rtl'; 4490 4491 const defineJQueryPlugin = plugin => { 4492 onDOMContentLoaded(() => { 4493 const $ = getjQuery(); 4494 /* istanbul ignore if */ 4495 4496 if ($) { 4497 const name = plugin.NAME; 4498 const JQUERY_NO_CONFLICT = $.fn[name]; 4499 $.fn[name] = plugin.jQueryInterface; 4500 $.fn[name].Constructor = plugin; 4501 4502 $.fn[name].noConflict = () => { 4503 $.fn[name] = JQUERY_NO_CONFLICT; 4504 return plugin.jQueryInterface; 4505 }; 4506 } 4507 }); 4508 }; 4509 /** 4510 * Return the previous/next element of a list. 4511 * 4512 * @param {array} list The list of elements 4513 * @param activeElement The active element 4514 * @param shouldGetNext Choose to get next or previous element 4515 * @param isCycleAllowed 4516 * @return {Element|elem} The proper element 4517 */ 4518 4519 4520 const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => { 4521 let index = list.indexOf(activeElement); // if the element does not exist in the list return an element depending on the direction and if cycle is allowed 4522 4523 if (index === -1) { 4524 return list[!shouldGetNext && isCycleAllowed ? list.length - 1 : 0]; 4525 } 4526 4527 const listLength = list.length; 4528 index += shouldGetNext ? 1 : -1; 4529 4530 if (isCycleAllowed) { 4531 index = (index + listLength) % listLength; 4532 } 4533 4534 return list[Math.max(0, Math.min(index, listLength - 1))]; 4535 }; 4536 4537 /** 4538 * -------------------------------------------------------------------------- 4539 * Bootstrap (v5.1.3): dropdown.js 4540 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4541 * -------------------------------------------------------------------------- 4542 */ 4543 /** 4544 * ------------------------------------------------------------------------ 4545 * Constants 4546 * ------------------------------------------------------------------------ 4547 */ 4548 4549 const NAME = 'dropdown'; 4550 const DATA_KEY = 'bs.dropdown'; 4551 const EVENT_KEY = `.${DATA_KEY}`; 4552 const DATA_API_KEY = '.data-api'; 4553 const ESCAPE_KEY = 'Escape'; 4554 const SPACE_KEY = 'Space'; 4555 const TAB_KEY = 'Tab'; 4556 const ARROW_UP_KEY = 'ArrowUp'; 4557 const ARROW_DOWN_KEY = 'ArrowDown'; 4558 const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button 4559
4560 const REGEXP_KEYDOWN = new RegExp(`${ARROW_UP_KEY}|${ARROW_DOWN_KEY}|${ESCAPE_KEY}`); 4561 const EVENT_HIDE = `hide${EVENT_KEY}`; 4562 const EVENT_HIDDEN = `hidden${EVENT_KEY}`; 4563 const EVENT_SHOW = `show${EVENT_KEY}`; 4564 const EVENT_SHOWN = `shown${EVENT_KEY}`; 4565 const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`; 4566 const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY}${DATA_API_KEY}`; 4567 const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY}${DATA_API_KEY}`; 4568 const CLASS_NAME_SHOW = 'show'; 4569 const CLASS_NAME_DROPUP = 'dropup'; 4570 const CLASS_NAME_DROPEND = 'dropend'; 4571 const CLASS_NAME_DROPSTART = 'dropstart'; 4572 const CLASS_NAME_NAVBAR = 'navbar'; 4573 const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="dropdown"]'; 4574 const SELECTOR_MENU = '.dropdown-menu'; 4575 const SELECTOR_NAVBAR_NAV = '.navbar-nav'; 4576 const SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'; 4577 const PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start'; 4578 const PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end'; 4579 const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start'; 4580 const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end'; 4581 const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start'; 4582 const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start'; 4583 const Default = { 4584 offset: [0, 2], 4585 boundary: 'clippingParents', 4586 reference: 'toggle', 4587 display: 'dynamic', 4588 popperConfig: null, 4589 autoClose: true 4590 }; 4591 const DefaultType = { 4592 offset: '(array|string|function)', 4593 boundary: '(string|element)', 4594 reference: '(string|element|object)', 4595 display: 'string', 4596 popperConfig: '(null|object|function)', 4597 autoClose: '(boolean|string)' 4598 }; 4599 /** 4600 * ------------------------------------------------------------------------ 4601 * Class Definition 4602 * ------------------------------------------------------------------------ 4603 */ 4604 4605 class Dropdown extends BaseComponent__default.default { 4606 constructor(element, config) { 4607 super(element); 4608 this._popper = null; 4609 this._config = this._getConfig(config); 4610 this._menu = this._getMenuElement(); 4611 this._inNavbar = this._detectNavbar(); 4612 } // Getters 4613 4614 4615 static get Default() { 4616 return Default; 4617 } 4618 4619 static get DefaultType() { 4620 return DefaultType; 4621 } 4622 4623 static get NAME() { 4624 return NAME; 4625 } // Public 4626 4627 4628 toggle() { 4629 return this._isShown() ? this.hide() : this.show(); 4630 } 4631 4632 show() { 4633 if (isDisabled(this._element) || this._isShown(this._menu)) { 4634 return; 4635 } 4636 4637 const relatedTarget = { 4638 relatedTarget: this._element 4639 }; 4640 const showEvent = EventHandler__default.default.trigger(this._element, EVENT_SHOW, relatedTarget); 4641 4642 if (showEvent.defaultPrevented) { 4643 return; 4644 } 4645 4646 const parent = Dropdown.getParentFromElement(this._element); // Totally disable Popper for Dropdowns in Navbar 4647 4648 if (this._inNavbar) { 4649 Manipulator__default.default.setDataAttribute(this._menu, 'popper', 'none'); 4650 } else { 4651 this._createPopper(parent); 4652 } // If this is a touch-enabled device we add extra 4653 // empty mouseover listeners to the body's immediate children; 4654 // only needed because of broken event delegation on iOS 4655 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 4656 4657 4658 if ('ontouchstart' in document.documentElement && !parent.closest(SELECTOR_NAVBAR_NAV)) { 4659 [].concat(...document.body.children).forEach(elem => EventHandler__default.default.on(elem, 'mouseover', noop)); 4660 } 4661 4662 this._element.focus(); 4663 4664 this._element.setAttribute('aria-expanded', true); 4665 4666 this._menu.classList.add(CLASS_NAME_SHOW); 4667 4668 this._element.classList.add(CLASS_NAME_SHOW); 4669 4670 EventHandler__default.default.trigger(this._element, EVENT_SHOWN, relatedTarget); 4671 } 4672 4673 hide() { 4674 if (isDisabled(this._element) || !this._isShown(this._menu)) { 4675 return; 4676 } 4677 4678 const relatedTarget = { 4679 relatedTarget: this._element 4680 }; 4681 4682 this._completeHide(relatedTarget); 4683 } 4684 4685 dispose() { 4686 if (this._popper) { 4687 this._popper.destroy(); 4688 } 4689 4690 super.dispose(); 4691 } 4692 4693 update() { 4694 this._inNavbar = this._detectNavbar(); 4695 4696 if (this._popper) {
4697 this._popper.update(); 4698 } 4699 } // Private 4700 4701 4702 _completeHide(relatedTarget) { 4703 const hideEvent = EventHandler__default.default.trigger(this._element, EVENT_HIDE, relatedTarget); 4704 4705 if (hideEvent.defaultPrevented) { 4706 return; 4707 } // If this is a touch-enabled device we remove the extra 4708 // empty mouseover listeners we added for iOS support 4709 4710 4711 if ('ontouchstart' in document.documentElement) { 4712 [].concat(...document.body.children).forEach(elem => EventHandler__default.default.off(elem, 'mouseover', noop)); 4713 } 4714 4715 if (this._popper) { 4716 this._popper.destroy(); 4717 } 4718 4719 this._menu.classList.remove(CLASS_NAME_SHOW); 4720 4721 this._element.classList.remove(CLASS_NAME_SHOW); 4722 4723 this._element.setAttribute('aria-expanded', 'false'); 4724 4725 Manipulator__default.default.removeDataAttribute(this._menu, 'popper'); 4726 EventHandler__default.default.trigger(this._element, EVENT_HIDDEN, relatedTarget); 4727 } 4728 4729 _getConfig(config) { 4730 config = { ...this.constructor.Default, 4731 ...Manipulator__default.default.getDataAttributes(this._element), 4732 ...config 4733 }; 4734 typeCheckConfig(NAME, config, this.constructor.DefaultType); 4735 4736 if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') { 4737 // Popper virtual elements require a getBoundingClientRect method 4738 throw new TypeError(`${NAME.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`); 4739 } 4740 4741 return config; 4742 } 4743 4744 _createPopper(parent) { 4745 if (typeof Popper__namespace === 'undefined') { 4746 throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)'); 4747 } 4748 4749 let referenceElement = this._element; 4750 4751 if (this._config.reference === 'parent') { 4752 referenceElement = parent; 4753 } else if (isElement(this._config.reference)) { 4754 referenceElement = getElement(this._config.reference); 4755 } else if (typeof this._config.reference === 'object') { 4756 referenceElement = this._config.reference; 4757 } 4758 4759 const popperConfig = this._getPopperConfig(); 4760 4761 const isDisplayStatic = popperConfig.modifiers.find(modifier => modifier.name === 'applyStyles' && modifier.enabled === false); 4762 this._popper = Popper__namespace.createPopper(referenceElement, this._menu, popperConfig); 4763 4764 if (isDisplayStatic) { 4765 Manipulator__default.default.setDataAttribute(this._menu, 'popper', 'static'); 4766 } 4767 } 4768 4769 _isShown(element = this._element) { 4770 return element.classList.contains(CLASS_NAME_SHOW); 4771 } 4772 4773 _getMenuElement() { 4774 return SelectorEngine__default.default.next(this._element, SELECTOR_MENU)[0]; 4775 } 4776 4777 _getPlacement() { 4778 const parentDropdown = this._element.parentNode; 4779 4780 if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) { 4781 return PLACEMENT_RIGHT; 4782 } 4783 4784 if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) { 4785 return PLACEMENT_LEFT; 4786 } // We need to trim the value because custom properties can also include spaces 4787 4788 4789 const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end'; 4790 4791 if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) { 4792 return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP; 4793 } 4794 4795 return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM; 4796 } 4797 4798 _detectNavbar() { 4799 return this._element.closest(`.${CLASS_NAME_NAVBAR}`) !== null; 4800 } 4801 4802 _getOffset() { 4803 const { 4804 offset 4805 } = this._config; 4806 4807 if (typeof offset === 'string') { 4808 return offset.split(',').map(val => Number.parseInt(val, 10)); 4809 } 4810 4811 if (typeof offset === 'function') { 4812 return popperData => offset(popperData, this._element); 4813 } 4814 4815 return offset; 4816 } 4817 4818 _getPopperConfig() { 4819 const defaultBsPopperConfig = { 4820 placement: this._getPlacement(), 4821 modifiers: [{ 4822 name: 'preventOverflow', 4823 options: {
4824 boundary: this._config.boundary 4825 } 4826 }, { 4827 name: 'offset', 4828 options: { 4829 offset: this._getOffset() 4830 } 4831 }] 4832 }; // Disable Popper if we have a static display 4833 4834 if (this._config.display === 'static') { 4835 defaultBsPopperConfig.modifiers = [{ 4836 name: 'applyStyles', 4837 enabled: false 4838 }]; 4839 } 4840 4841 return { ...defaultBsPopperConfig, 4842 ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig) 4843 }; 4844 } 4845 4846 _selectMenuItem({ 4847 key, 4848 target 4849 }) { 4850 const items = SelectorEngine__default.default.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(isVisible); 4851 4852 if (!items.length) { 4853 return; 4854 } // if target isn't included in items (e.g. when expanding the dropdown) 4855 // allow cycling to get the last item in case key equals ARROW_UP_KEY 4856 4857 4858 getNextActiveElement(items, target, key === ARROW_DOWN_KEY, !items.includes(target)).focus(); 4859 } // Static 4860 4861 4862 static jQueryInterface(config) { 4863 return this.each(function () { 4864 const data = Dropdown.getOrCreateInstance(this, config); 4865 4866 if (typeof config !== 'string') { 4867 return; 4868 } 4869 4870 if (typeof data[config] === 'undefined') { 4871 throw new TypeError(`No method named "${config}"`); 4872 } 4873 4874 data[config](); 4875 }); 4876 } 4877 4878 static clearMenus(event) { 4879 if (event && (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY)) { 4880 return; 4881 } 4882 4883 const toggles = SelectorEngine__default.default.find(SELECTOR_DATA_TOGGLE); 4884 4885 for (let i = 0, len = toggles.length; i < len; i++) { 4886 const context = Dropdown.getInstance(toggles[i]); 4887 4888 if (!context || context._config.autoClose === false) { 4889 continue; 4890 } 4891 4892 if (!context._isShown()) { 4893 continue; 4894 } 4895 4896 const relatedTarget = { 4897 relatedTarget: context._element 4898 }; 4899 4900 if (event) { 4901 const composedPath = event.composedPath(); 4902 const isMenuTarget = composedPath.includes(context._menu); 4903 4904 if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) { 4905 continue; 4906 } // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu 4907 4908 4909 if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY || /input|select|option|textarea|form/i.test(event.target.tagName))) { 4910 continue; 4911 } 4912 4913 if (event.type === 'click') { 4914 relatedTarget.clickEvent = event; 4915 } 4916 } 4917 4918 context._completeHide(relatedTarget); 4919 } 4920 } 4921 4922 static getParentFromElement(element) { 4923 return getElementFromSelector(element) || element.parentNode; 4924 } 4925 4926 static dataApiKeydownHandler(event) { 4927 // If not input/textarea: 4928 // - And not a key in REGEXP_KEYDOWN => not a dropdown command 4929 // If input/textarea: 4930 // - If space key => not a dropdown command 4931 // - If key is other than escape 4932 // - If key is not up or down => not a dropdown command 4933 // - If trigger inside the menu => not a dropdown command 4934 if (/input|textarea/i.test(event.target.tagName) ? event.key === SPACE_KEY || event.key !== ESCAPE_KEY && (event.key !== ARROW_DOWN_KEY && event.key !== ARROW_UP_KEY || event.target.closest(SELECTOR_MENU)) : !REGEXP_KEYDOWN.test(event.key)) { 4935 return; 4936 } 4937 4938 const isActive = this.classList.contains(CLASS_NAME_SHOW); 4939 4940 if (!isActive && event.key === ESCAPE_KEY) { 4941 return; 4942 } 4943 4944 event.preventDefault(); 4945 event.stopPropagation(); 4946 4947 if (isDisabled(this)) { 4948 return; 4949 } 4950 4951 const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE) ? this
4951: SelectorEngine__default.default.prev(this, SELECTOR_DATA_TOGGLE)[0]; 4952 const instance = Dropdown.getOrCreateInstance(getToggleButton); 4953 4954 if (event.key === ESCAPE_KEY) { 4955 instance.hide(); 4956 return; 4957 } 4958 4959 if (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY) { 4960 if (!isActive) { 4961 instance.show(); 4962 } 4963 4964 instance._selectMenuItem(event); 4965 4966 return; 4967 } 4968 4969 if (!isActive || event.key === SPACE_KEY) { 4970 Dropdown.clearMenus(); 4971 } 4972 } 4973 4974 } 4975 /** 4976 * ------------------------------------------------------------------------ 4977 * Data Api implementation 4978 * ------------------------------------------------------------------------ 4979 */ 4980 4981 4982 EventHandler__default.default.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE, Dropdown.dataApiKeydownHandler); 4983 EventHandler__default.default.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler); 4984 EventHandler__default.default.on(document, EVENT_CLICK_DATA_API, Dropdown.clearMenus); 4985 EventHandler__default.default.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus); 4986 EventHandler__default.default.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { 4987 event.preventDefault(); 4988 Dropdown.getOrCreateInstance(this).toggle(); 4989 }); 4990 /** 4991 * ------------------------------------------------------------------------ 4992 * jQuery 4993 * ------------------------------------------------------------------------ 4994 * add .Dropdown to jQuery only if jQuery is present 4995 */ 4996 4997 defineJQueryPlugin(Dropdown); 4998 4999 return Dropdown; 5000 5001 })); 5002 5003 }(dropdown$1)); 5004 5005 var dropdown = /*@__PURE__*/getDefaultExportFromCjs(dropdown$1.exports); 5006 5007 var modal$1 = {exports: {}}; 5008 5009 /*! 5010 * Bootstrap modal.js v5.1.3 (https://getbootstrap.com/) 5011 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 5012 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5013 */ 5014 5015 (function (module, exports) { 5016 (function (global, factory) { 5017 module.exports = factory(eventHandler.exports, manipulator.exports, selectorEngine.exports, baseComponent.exports) ; 5018 })(commonjsGlobal, (function (EventHandler, Manipulator, SelectorEngine, BaseComponent) { 5019 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 5020 5021 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 5022 const Manipulator__default = /*#__PURE__*/_interopDefaultLegacy(Manipulator); 5023 const SelectorEngine__default = /*#__PURE__*/_interopDefaultLegacy(SelectorEngine); 5024 const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); 5025 5026 /** 5027 * -------------------------------------------------------------------------- 5028 * Bootstrap (v5.1.3): util/index.js 5029 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5030 * -------------------------------------------------------------------------- 5031 */ 5032 const MILLISECONDS_MULTIPLIER = 1000; 5033 const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp) 5034 5035 const toType = obj => { 5036 if (obj === null || obj === undefined) { 5037 return `${obj}`; 5038 } 5039 5040 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 5041 }; 5042 5043 const getSelector = element => { 5044 let selector = element.getAttribute('data-bs-target'); 5045 5046 if (!selector || selector === '#') { 5047 let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes, 5048 // so everything starting with `#` or `.`. If a "real" URL is used as the selector, 5049 // `document.querySelector` will rightfully complain it is invalid. 5050 // See https://github.com/twbs/bootstrap/issues/32273 5051 5052 if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) { 5053 return null; 5054 } // Just in case some CMS puts out a full URL with the anchor appended 5055 5056 5057 if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) { 5058 hrefAttr = `#${hrefAttr.split('#')[1]}`; 5059 } 5060 5061 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null; 5062 } 5063 5064 return selector; 5065 }; 5066 5067 const getElementFromSelector = element => { 5068 const selector = getSelector(element); 5069 return selector ? document.querySelector(selector) : null; 5070 }; 5071 5072 const getTransitionDurationFromElement = element => { 5073 if (!element) { 5074 return 0; 5075 } // Get transition-duration of the element 5076 5077 5078 let { 5079 transitionDuration, 5080 transitionDelay 5081 } = window.getComputedStyle(element); 5082 const floatTransitionDuration = Number.parseFloat(transitionDuration); 5083 const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found 5084 5085 if (!floatTransitionDuration && !floatTransitionDelay) { 5086 return 0; 5087 } // If multiple durations are defined, take the first 5088 5089 5090 transitionDuration = transitionDuration.split(',')[0]; 5091 transitionDelay = transitionDelay.split(',')[0]; 5092 return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; 5093 }; 5094 5095 const triggerTransitionEnd = element => { 5096 element.dispatchEvent(new Event(TRANSITION_END)); 5097 }; 5098 5099 const isElement = obj => { 5100 if (!obj || typeof obj !== 'object') { 5101 return false;
5102 } 5103 5104 if (typeof obj.jquery !== 'undefined') { 5105 obj = obj[0]; 5106 } 5107 5108 return typeof obj.nodeType !== 'undefined'; 5109 }; 5110 5111 const getElement = obj => { 5112 if (isElement(obj)) { 5113 // it's a jQuery object or a node element 5114 return obj.jquery ? obj[0] : obj; 5115 } 5116 5117 if (typeof obj === 'string' && obj.length > 0) { 5118 return document.querySelector(obj); 5119 } 5120 5121 return null; 5122 }; 5123 5124 const typeCheckConfig = (componentName, config, configTypes) => { 5125 Object.keys(configTypes).forEach(property => { 5126 const expectedTypes = configTypes[property]; 5127 const value = config[property]; 5128 const valueType = value && isElement(value) ? 'element' : toType(value); 5129 5130 if (!new RegExp(expectedTypes).test(valueType)) { 5131 throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); 5132 } 5133 }); 5134 }; 5135 5136 const isVisible = element => { 5137 if (!isElement(element) || element.getClientRects().length === 0) { 5138 return false; 5139 } 5140 5141 return getComputedStyle(element).getPropertyValue('visibility') === 'visible'; 5142 }; 5143 5144 const isDisabled = element => { 5145 if (!element || element.nodeType !== Node.ELEMENT_NODE) { 5146 return true; 5147 } 5148 5149 if (element.classList.contains('disabled')) { 5150 return true; 5151 } 5152 5153 if (typeof element.disabled !== 'undefined') { 5154 return element.disabled; 5155 } 5156 5157 return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'; 5158 }; 5159 /** 5160 * Trick to restart an element's animation 5161 * 5162 * @param {HTMLElement} element 5163 * @return void 5164 * 5165 * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation 5166 */ 5167 5168 5169 const reflow = element => { 5170 // eslint-disable-next-line no-unused-expressions 5171 element.offsetHeight; 5172 }; 5173 5174 const getjQuery = () => { 5175 const { 5176 jQuery 5177 } = window; 5178 5179 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 5180 return jQuery; 5181 } 5182 5183 return null; 5184 }; 5185 5186 const DOMContentLoadedCallbacks = []; 5187 5188 const onDOMContentLoaded = callback => { 5189 if (document.readyState === 'loading') { 5190 // add listener on the first call when the document is in loading state 5191 if (!DOMContentLoadedCallbacks.length) { 5192 document.addEventListener('DOMContentLoaded', () => { 5193 DOMContentLoadedCallbacks.forEach(callback => callback()); 5194 }); 5195 } 5196 5197 DOMContentLoadedCallbacks.push(callback); 5198 } else { 5199 callback(); 5200 } 5201 }; 5202 5203 const isRTL = () => document.documentElement.dir === 'rtl'; 5204 5205 const defineJQueryPlugin = plugin => { 5206 onDOMContentLoaded(() => { 5207 const $ = getjQuery(); 5208 /* istanbul ignore if */ 5209 5210 if ($) { 5211 const name = plugin.NAME; 5212 const JQUERY_NO_CONFLICT = $.fn[name]; 5213 $.fn[name] = plugin.jQueryInterface; 5214 $.fn[name].Constructor = plugin; 5215 5216 $.fn[name].noConflict = () => { 5217 $.fn[name] = JQUERY_NO_CONFLICT; 5218 return plugin.jQueryInterface; 5219 }; 5220 } 5221 }); 5222 }; 5223 5224 const execute = callback => { 5225 if (typeof callback === 'function') { 5226 callback(); 5227 } 5228 }; 5229 5230 const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => { 5231 if (!waitForTransition) { 5232 execute(callback); 5233 return; 5234 } 5235 5236 const durationPadding = 5; 5237 const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding; 5238 let called = false; 5239 5240 const handler = ({ 5241 target 5242 }) => { 5243 if (target !== transitionElement) { 5244 return; 5245 } 5246 5247 called = true; 5248 transitionElement.removeEventListener(TRANSITION_END, handler); 5249 execute(callback); 5250 }; 5251 5252 transitionElement.addEventListener(TRANSITION_END, handler); 5253 setTimeout(() => { 5254 if (!called) { 5255 triggerTransitionEnd(transitionElement); 5256 } 5257 }, emulatedDuration); 5258 }; 5259 5260 /** 5261 * -------------------------------------------------------------------------- 5262 * Bootstrap (v5.1.3): util/scrollBar.js 5263 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5264 * -------------------------------------------------------------------------- 5265 */ 5266 const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'; 5267 const SELECTOR_STICKY_CONTENT = '.sticky-top'; 5268 5269 class ScrollBarHelper { 5270 constructor() { 5271 this._element = document.body; 5272 } 5273 5274 getWidth() { 5275 // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes 5276 const documentWidth = document.documentElement.clientWidth; 5277 return Math.abs(window.innerWidth - documentWidth); 5278 } 5279 5280 hide() { 5281 const width = this.getWidth(); 5282 5283 this._disableOverFlow(); // give padding to element to balance the hidden scrollbar width 5284 5285 5286 this._setElementAttributes(this._element, 'paddingRight', calculatedValue => calculatedValue + width);
5286 // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth 5287 5288 5289 this._setElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight', calculatedValue => calculatedValue + width); 5290 5291 this._setElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight', calculatedValue => calculatedValue - width); 5292 } 5293 5294 _disableOverFlow() { 5295 this._saveInitialAttribute(this._element, 'overflow'); 5296 5297 this._element.style.overflow = 'hidden'; 5298 } 5299 5300 _setElementAttributes(selector, styleProp, callback) { 5301 const scrollbarWidth = this.getWidth(); 5302 5303 const manipulationCallBack = element => { 5304 if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) { 5305 return; 5306 } 5307 5308 this._saveInitialAttribute(element, styleProp); 5309 5310 const calculatedValue = window.getComputedStyle(element)[styleProp]; 5311 element.style[styleProp] = `${callback(Number.parseFloat(calculatedValue))}px`; 5312 }; 5313 5314 this._applyManipulationCallback(selector, manipulationCallBack); 5315 } 5316 5317 reset() { 5318 this._resetElementAttributes(this._element, 'overflow'); 5319 5320 this._resetElementAttributes(this._element, 'paddingRight'); 5321 5322 this._resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight'); 5323 5324 this._resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight'); 5325 } 5326 5327 _saveInitialAttribute(element, styleProp) { 5328 const actualValue = element.style[styleProp]; 5329 5330 if (actualValue) { 5331 Manipulator__default.default.setDataAttribute(element, styleProp, actualValue); 5332 } 5333 } 5334 5335 _resetElementAttributes(selector, styleProp) { 5336 const manipulationCallBack = element => { 5337 const value = Manipulator__default.default.getDataAttribute(element, styleProp); 5338 5339 if (typeof value === 'undefined') { 5340 element.style.removeProperty(styleProp); 5341 } else { 5342 Manipulator__default.default.removeDataAttribute(element, styleProp); 5343 element.style[styleProp] = value; 5344 } 5345 }; 5346 5347 this._applyManipulationCallback(selector, manipulationCallBack); 5348 } 5349 5350 _applyManipulationCallback(selector, callBack) { 5351 if (isElement(selector)) { 5352 callBack(selector); 5353 } else { 5354 SelectorEngine__default.default.find(selector, this._element).forEach(callBack); 5355 } 5356 } 5357 5358 isOverflowing() { 5359 return this.getWidth() > 0; 5360 } 5361 5362 } 5363 5364 /** 5365 * -------------------------------------------------------------------------- 5366 * Bootstrap (v5.1.3): util/backdrop.js 5367 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5368 * -------------------------------------------------------------------------- 5369 */ 5370 const Default$2 = { 5371 className: 'modal-backdrop', 5372 isVisible: true, 5373 // if false, we use the backdrop helper without adding any element to the dom 5374 isAnimated: false, 5375 rootElement: 'body', 5376 // give the choice to place backdrop under different elements 5377 clickCallback: null 5378 }; 5379 const DefaultType$2 = { 5380 className: 'string', 5381 isVisible: 'boolean', 5382 isAnimated: 'boolean', 5383 rootElement: '(element|string)', 5384 clickCallback: '(function|null)' 5385 }; 5386 const NAME$2 = 'backdrop'; 5387 const CLASS_NAME_FADE$1 = 'fade'; 5388 const CLASS_NAME_SHOW$1 = 'show'; 5389 const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$2}`; 5390 5391 class Backdrop { 5392 constructor(config) { 5393 this._config = this._getConfig(config); 5394 this._isAppended = false; 5395 this._element = null; 5396 } 5397 5398 show(callback) { 5399 if (!this._config.isVisible) { 5400 execute(callback); 5401 return; 5402 } 5403 5404 this._append(); 5405 5406 if (this._config.isAnimated) { 5407 reflow(this._getElement()); 5408 } 5409 5410 this._getElement().classList.add(CLASS_NAME_SHOW$1); 5411 5412 this._emulateAnimation(() => { 5413 execute(callback); 5414 }); 5415 } 5416 5417 hide(callback) { 5418 if (!this._config.isVisible) { 5419 execute(callback); 5420 return; 5421 } 5422 5423 this._getElement().classList.remove(CLASS_NAME_SHOW$1); 5424 5425 this._emulateAnimation(() => { 5426 this.dispose(); 5427 execute(callback); 5428 }); 5429 } // Private 5430 5431 5432 _getElement() { 5433 if (!this._element) { 5434 const backdrop = document.createElement('div'); 5435 backdrop.className = this._config.className; 5436 5437 if (this._config.isAnimated) { 5438 backdrop.classList.add(CLASS_NAME_FADE$1); 5439 } 5440 5441 this._element = backdrop; 5442 } 5443 5444 return this._element; 5445 } 5446 5447 _getConfig(config) { 5448 config = { ...Default$2, 5449 ...(typeof config === 'object' ? config : {}) 5450 }; // use getElement() with the default "body" to get a fresh Element on each instantiation 5451 5452 config.rootElement = getElement(config.rootElement); 5453 typeCheckConfig(NAME$2, config, DefaultType$2); 5454 return config; 5455 } 5456 5457 _append() { 5458 if (this._isAppended) { 5459 return; 5460 } 5461 5462 this._config.rootElement.append(this._getElement()); 5463 5464 EventHandler__default.default.on(this._getElement(), EVENT_MOUSEDOWN, () => { 5465 execute(this._config.clickCallback); 5466 }); 5467 this._isAppended = true; 5468 } 5469 5470 dispose() { 5471 if (!this._isAppended) { 5472 return; 5473 } 5474 5475 EventHandler__default.default.off(this._element, EVENT_MOUSEDOWN); 5476 5477 this._element.remove(); 5478 5479 this._isAppended = false;
5480 } 5481 5482 _emulateAnimation(callback) { 5483 executeAfterTransition(callback, this._getElement(), this._config.isAnimated); 5484 } 5485 5486 } 5487 5488 /** 5489 * -------------------------------------------------------------------------- 5490 * Bootstrap (v5.1.3): util/focustrap.js 5491 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5492 * -------------------------------------------------------------------------- 5493 */ 5494 const Default$1 = { 5495 trapElement: null, 5496 // The element to trap focus inside of 5497 autofocus: true 5498 }; 5499 const DefaultType$1 = { 5500 trapElement: 'element', 5501 autofocus: 'boolean' 5502 }; 5503 const NAME$1 = 'focustrap'; 5504 const DATA_KEY$1 = 'bs.focustrap'; 5505 const EVENT_KEY$1 = `.${DATA_KEY$1}`; 5506 const EVENT_FOCUSIN = `focusin${EVENT_KEY$1}`; 5507 const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$1}`; 5508 const TAB_KEY = 'Tab'; 5509 const TAB_NAV_FORWARD = 'forward'; 5510 const TAB_NAV_BACKWARD = 'backward'; 5511 5512 class FocusTrap { 5513 constructor(config) { 5514 this._config = this._getConfig(config); 5515 this._isActive = false; 5516 this._lastTabNavDirection = null; 5517 } 5518 5519 activate() { 5520 const { 5521 trapElement, 5522 autofocus 5523 } = this._config; 5524 5525 if (this._isActive) { 5526 return; 5527 } 5528 5529 if (autofocus) { 5530 trapElement.focus(); 5531 } 5532 5533 EventHandler__default.default.off(document, EVENT_KEY$1); // guard against infinite focus loop 5534 5535 EventHandler__default.default.on(document, EVENT_FOCUSIN, event => this._handleFocusin(event)); 5536 EventHandler__default.default.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event)); 5537 this._isActive = true; 5538 } 5539 5540 deactivate() { 5541 if (!this._isActive) { 5542 return; 5543 } 5544 5545 this._isActive = false; 5546 EventHandler__default.default.off(document, EVENT_KEY$1); 5547 } // Private 5548 5549 5550 _handleFocusin(event) { 5551 const { 5552 target 5553 } = event; 5554 const { 5555 trapElement 5556 } = this._config; 5557 5558 if (target === document || target === trapElement || trapElement.contains(target)) { 5559 return; 5560 } 5561 5562 const elements = SelectorEngine__default.default.focusableChildren(trapElement); 5563 5564 if (elements.length === 0) { 5565 trapElement.focus(); 5566 } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) { 5567 elements[elements.length - 1].focus(); 5568 } else { 5569 elements[0].focus(); 5570 } 5571 } 5572 5573 _handleKeydown(event) { 5574 if (event.key !== TAB_KEY) { 5575 return; 5576 } 5577 5578 this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD; 5579 } 5580 5581 _getConfig(config) { 5582 config = { ...Default$1, 5583 ...(typeof config === 'object' ? config : {}) 5584 }; 5585 typeCheckConfig(NAME$1, config, DefaultType$1); 5586 return config; 5587 } 5588 5589 } 5590 5591 /** 5592 * -------------------------------------------------------------------------- 5593 * Bootstrap (v5.1.3): util/component-functions.js 5594 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5595 * -------------------------------------------------------------------------- 5596 */ 5597 5598 const enableDismissTrigger = (component, method = 'hide') => { 5599 const clickEvent = `click.dismiss${component.EVENT_KEY}`; 5600 const name = component.NAME; 5601 EventHandler__default.default.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) { 5602 if (['A', 'AREA'].includes(this.tagName)) { 5603 event.preventDefault(); 5604 } 5605 5606 if (isDisabled(this)) { 5607 return; 5608 } 5609 5610 const target = getElementFromSelector(this) || this.closest(`.${name}`); 5611 const instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method 5612 5613 instance[method](); 5614 }); 5615 }; 5616 5617 /** 5618 * -------------------------------------------------------------------------- 5619 * Bootstrap (v5.1.3): modal.js 5620 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5621 * -------------------------------------------------------------------------- 5622 */ 5623 /** 5624 * ------------------------------------------------------------------------ 5625 * Constants 5626 * ------------------------------------------------------------------------ 5627 */ 5628 5629 const NAME = 'modal'; 5630 const DATA_KEY = 'bs.modal'; 5631 const EVENT_KEY = `.${DATA_KEY}`; 5632 const DATA_API_KEY = '.data-api'; 5633 const ESCAPE_KEY = 'Escape'; 5634 const Default = { 5635 backdrop: true, 5636 keyboard: true, 5637 focus: true 5638 }; 5639 const DefaultType = { 5640 backdrop: '(boolean|string)', 5641 keyboard: 'boolean', 5642 focus: 'boolean' 5643 }; 5644 const EVENT_HIDE = `hide${EVENT_KEY}`; 5645 const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY}`; 5646 const EVENT_HIDDEN = `hidden${EVENT_KEY}`; 5647 const EVENT_SHOW = `show${EVENT_KEY}`; 5648 const EVENT_SHOWN = `shown${EVENT_KEY}`; 5649 const EVENT_RESIZE = `resize${EVENT_KEY}`; 5650 const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY}`; 5651 const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY}`; 5652 const EVENT_MOUSEUP_DISMISS = `mouseup.dismiss${EVENT_KEY}`; 5653 const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY}`; 5654 const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`; 5655 const CLASS_NAME_OPEN = 'modal-open'; 5656 const CLASS_NAME_FADE = 'fade'; 5657 const CLASS_NAME_SHOW = 'show'; 5658 const CLASS_NAME_STATIC = 'modal-static'; 5659 const OPEN_SELECTOR = '.modal.show'; 5660 const SELECTOR_DIALOG = '.modal-dialog'; 5661 const SELECTOR_MODAL_BODY = '.modal-body'; 5662 const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="modal"]'; 5663 /** 5664 * ------------------------------------------------------------------------ 5665 * Class Definition 5666 * ------------------------------------------------------------------------ 5667 */ 5668 5669 class Modal extends BaseComponent__default.default { 5670 constructor(element, config) { 5671 super(element); 5672 this._config = this._getConfig(config); 5673 this._dialog = SelectorEngine__default.default.findOne(SELECTOR_DIALOG, this._element); 5674 this._backdrop = this._initializeBackDrop(); 5675 this._focustrap = this._initializeFocusTrap(); 5676 this._isShown = false;
5677 this._ignoreBackdropClick = false; 5678 this._isTransitioning = false; 5679 this._scrollBar = new ScrollBarHelper(); 5680 } // Getters 5681 5682 5683 static get Default() { 5684 return Default; 5685 } 5686 5687 static get NAME() { 5688 return NAME; 5689 } // Public 5690 5691 5692 toggle(relatedTarget) { 5693 return this._isShown ? this.hide() : this.show(relatedTarget); 5694 } 5695 5696 show(relatedTarget) { 5697 if (this._isShown || this._isTransitioning) { 5698 return; 5699 } 5700 5701 const showEvent = EventHandler__default.default.trigger(this._element, EVENT_SHOW, { 5702 relatedTarget 5703 }); 5704 5705 if (showEvent.defaultPrevented) { 5706 return; 5707 } 5708 5709 this._isShown = true; 5710 5711 if (this._isAnimated()) { 5712 this._isTransitioning = true; 5713 } 5714 5715 this._scrollBar.hide(); 5716 5717 document.body.classList.add(CLASS_NAME_OPEN); 5718 5719 this._adjustDialog(); 5720 5721 this._setEscapeEvent(); 5722 5723 this._setResizeEvent(); 5724 5725 EventHandler__default.default.on(this._dialog, EVENT_MOUSEDOWN_DISMISS, () => { 5726 EventHandler__default.default.one(this._element, EVENT_MOUSEUP_DISMISS, event => { 5727 if (event.target === this._element) { 5728 this._ignoreBackdropClick = true; 5729 } 5730 }); 5731 }); 5732 5733 this._showBackdrop(() => this._showElement(relatedTarget)); 5734 } 5735 5736 hide() { 5737 if (!this._isShown || this._isTransitioning) { 5738 return; 5739 } 5740 5741 const hideEvent = EventHandler__default.default.trigger(this._element, EVENT_HIDE); 5742 5743 if (hideEvent.defaultPrevented) { 5744 return; 5745 } 5746 5747 this._isShown = false; 5748 5749 const isAnimated = this._isAnimated(); 5750 5751 if (isAnimated) { 5752 this._isTransitioning = true; 5753 } 5754 5755 this._setEscapeEvent(); 5756 5757 this._setResizeEvent(); 5758 5759 this._focustrap.deactivate(); 5760 5761 this._element.classList.remove(CLASS_NAME_SHOW); 5762 5763 EventHandler__default.default.off(this._element, EVENT_CLICK_DISMISS); 5764 EventHandler__default.default.off(this._dialog, EVENT_MOUSEDOWN_DISMISS); 5765 5766 this._queueCallback(() => this._hideModal(), this._element, isAnimated); 5767 } 5768 5769 dispose() { 5770 [window, this._dialog].forEach(htmlElement => EventHandler__default.default.off(htmlElement, EVENT_KEY)); 5771 5772 this._backdrop.dispose(); 5773 5774 this._focustrap.deactivate(); 5775 5776 super.dispose(); 5777 } 5778 5779 handleUpdate() { 5780 this._adjustDialog(); 5781 } // Private 5782 5783 5784 _initializeBackDrop() { 5785 return new Backdrop({ 5786 isVisible: Boolean(this._config.backdrop), 5787 // 'static' option will be translated to true, and booleans will keep their value 5788 isAnimated: this._isAnimated() 5789 }); 5790 } 5791 5792 _initializeFocusTrap() { 5793 return new FocusTrap({ 5794 trapElement: this._element 5795 }); 5796 } 5797 5798 _getConfig(config) { 5799 config = { ...Default, 5800 ...Manipulator__default.default.getDataAttributes(this._element), 5801 ...(typeof config === 'object' ? config : {}) 5802 }; 5803 typeCheckConfig(NAME, config, DefaultType); 5804 return config; 5805 } 5806 5807 _showElement(relatedTarget) { 5808 const isAnimated = this._isAnimated(); 5809 5810 const modalBody = SelectorEngine__default.default.findOne(SELECTOR_MODAL_BODY, this._dialog); 5811 5812 if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) { 5813 // Don't move modal's DOM position 5814 document.body.append(this._element); 5815 } 5816 5817 this._element.style.display = 'block'; 5818 5819 this._element.removeAttribute('aria-hidden'); 5820 5821 this._element.setAttribute('aria-modal', true); 5822 5823 this._element.setAttribute('role', 'dialog'); 5824 5825 this._element.scrollTop = 0; 5826 5827 if (modalBody) { 5828 modalBody.scrollTop = 0; 5829 } 5830 5831 if (isAnimated) { 5832 reflow(this._element); 5833 } 5834 5835 this._element.classList.add(CLASS_NAME_SHOW); 5836 5837 const transitionComplete = () => { 5838 if (this._config.focus) { 5839 this._focustrap.activate(); 5840 } 5841 5842 this._isTransitioning = false;
5843 EventHandler__default.default.trigger(this._element, EVENT_SHOWN, { 5844 relatedTarget 5845 }); 5846 }; 5847 5848 this._queueCallback(transitionComplete, this._dialog, isAnimated); 5849 } 5850 5851 _setEscapeEvent() { 5852 if (this._isShown) { 5853 EventHandler__default.default.on(this._element, EVENT_KEYDOWN_DISMISS, event => { 5854 if (this._config.keyboard && event.key === ESCAPE_KEY) { 5855 event.preventDefault(); 5856 this.hide(); 5857 } else if (!this._config.keyboard && event.key === ESCAPE_KEY) { 5858 this._triggerBackdropTransition(); 5859 } 5860 }); 5861 } else { 5862 EventHandler__default.default.off(this._element, EVENT_KEYDOWN_DISMISS); 5863 } 5864 } 5865 5866 _setResizeEvent() { 5867 if (this._isShown) { 5868 EventHandler__default.default.on(window, EVENT_RESIZE, () => this._adjustDialog()); 5869 } else { 5870 EventHandler__default.default.off(window, EVENT_RESIZE); 5871 } 5872 } 5873 5874 _hideModal() { 5875 this._element.style.display = 'none'; 5876 5877 this._element.setAttribute('aria-hidden', true); 5878 5879 this._element.removeAttribute('aria-modal'); 5880 5881 this._element.removeAttribute('role'); 5882 5883 this._isTransitioning = false; 5884 5885 this._backdrop.hide(() => { 5886 document.body.classList.remove(CLASS_NAME_OPEN); 5887 5888 this._resetAdjustments(); 5889 5890 this._scrollBar.reset(); 5891 5892 EventHandler__default.default.trigger(this._element, EVENT_HIDDEN); 5893 }); 5894 } 5895 5896 _showBackdrop(callback) { 5897 EventHandler__default.default.on(this._element, EVENT_CLICK_DISMISS, event => { 5898 if (this._ignoreBackdropClick) { 5899 this._ignoreBackdropClick = false; 5900 return; 5901 } 5902 5903 if (event.target !== event.currentTarget) { 5904 return; 5905 } 5906 5907 if (this._config.backdrop === true) { 5908 this.hide(); 5909 } else if (this._config.backdrop === 'static') { 5910 this._triggerBackdropTransition(); 5911 } 5912 }); 5913 5914 this._backdrop.show(callback); 5915 } 5916 5917 _isAnimated() { 5918 return this._element.classList.contains(CLASS_NAME_FADE); 5919 } 5920 5921 _triggerBackdropTransition() { 5922 const hideEvent = EventHandler__default.default.trigger(this._element, EVENT_HIDE_PREVENTED); 5923 5924 if (hideEvent.defaultPrevented) { 5925 return; 5926 } 5927 5928 const { 5929 classList, 5930 scrollHeight, 5931 style 5932 } = this._element; 5933 const isModalOverflowing = scrollHeight > document.documentElement.clientHeight; // return if the following background transition hasn't yet completed 5934 5935 if (!isModalOverflowing && style.overflowY === 'hidden' || classList.contains(CLASS_NAME_STATIC)) { 5936 return; 5937 } 5938 5939 if (!isModalOverflowing) { 5940 style.overflowY = 'hidden'; 5941 } 5942 5943 classList.add(CLASS_NAME_STATIC); 5944 5945 this._queueCallback(() => { 5946 classList.remove(CLASS_NAME_STATIC); 5947 5948 if (!isModalOverflowing) { 5949 this._queueCallback(() => { 5950 style.overflowY = ''; 5951 }, this._dialog); 5952 } 5953 }, this._dialog); 5954 5955 this._element.focus(); 5956 } // ---------------------------------------------------------------------- 5957 // the following methods are used to handle overflowing modals 5958 // ---------------------------------------------------------------------- 5959 5960 5961 _adjustDialog() { 5962 const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 5963 5964 const scrollbarWidth = this._scrollBar.getWidth(); 5965 5966 const isBodyOverflowing = scrollbarWidth > 0; 5967 5968 if (!isBodyOverflowing && isModalOverflowing && !isRTL() || isBodyOverflowing && !isModalOverflowing && isRTL()) { 5969 this._element.style.paddingLeft = `${scrollbarWidth}px`; 5970 } 5971 5972 if (isBodyOverflowing && !isModalOverflowing && !isRTL() || !isBodyOverflowing && isModalOverflowing && isRTL()) { 5973 this._element.style.paddingRight = `${scrollbarWidth}px`; 5974 } 5975 } 5976 5977 _resetAdjustments() { 5978 this._element.style.paddingLeft = ''; 5979 this._element.style.paddingRight = ''; 5980 } // Static 5981 5982 5983 static jQueryInterface(config, relatedTarget) { 5984 return this.each(function () { 5985 const data = Modal.getOrCreateInstance(this, config); 5986 5987 if (typeof config !== 'string') { 5988 return; 5989 } 5990 5991 if (typeof data[config] === 'undefined') {
5992 throw new TypeError(`No method named "${config}"`); 5993 } 5994 5995 data[config](relatedTarget); 5996 }); 5997 } 5998 5999 } 6000 /** 6001 * ------------------------------------------------------------------------ 6002 * Data Api implementation 6003 * ------------------------------------------------------------------------ 6004 */ 6005 6006 6007 EventHandler__default.default.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { 6008 const target = getElementFromSelector(this); 6009 6010 if (['A', 'AREA'].includes(this.tagName)) { 6011 event.preventDefault(); 6012 } 6013 6014 EventHandler__default.default.one(target, EVENT_SHOW, showEvent => { 6015 if (showEvent.defaultPrevented) { 6016 // only register focus restorer if modal will actually get shown 6017 return; 6018 } 6019 6020 EventHandler__default.default.one(target, EVENT_HIDDEN, () => { 6021 if (isVisible(this)) { 6022 this.focus(); 6023 } 6024 }); 6025 }); // avoid conflict when clicking moddal toggler while another one is open 6026 6027 const allReadyOpen = SelectorEngine__default.default.findOne(OPEN_SELECTOR); 6028 6029 if (allReadyOpen) { 6030 Modal.getInstance(allReadyOpen).hide(); 6031 } 6032 6033 const data = Modal.getOrCreateInstance(target); 6034 data.toggle(this); 6035 }); 6036 enableDismissTrigger(Modal); 6037 /** 6038 * ------------------------------------------------------------------------ 6039 * jQuery 6040 * ------------------------------------------------------------------------ 6041 * add .Modal to jQuery only if jQuery is present 6042 */ 6043 6044 defineJQueryPlugin(Modal); 6045 6046 return Modal; 6047 6048 })); 6049 6050 }(modal$1)); 6051 6052 var modal = modal$1.exports; 6053 6054 var offcanvas$1 = {exports: {}}; 6055 6056 /*! 6057 * Bootstrap offcanvas.js v5.1.3 (https://getbootstrap.com/) 6058 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 6059 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6060 */ 6061 6062 (function (module, exports) { 6063 (function (global, factory) { 6064 module.exports = factory(selectorEngine.exports, manipulator.exports, eventHandler.exports, baseComponent.exports) ; 6065 })(commonjsGlobal, (function (SelectorEngine, Manipulator, EventHandler, BaseComponent) { 6066 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 6067 6068 const SelectorEngine__default = /*#__PURE__*/_interopDefaultLegacy(SelectorEngine); 6069 const Manipulator__default = /*#__PURE__*/_interopDefaultLegacy(Manipulator); 6070 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 6071 const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); 6072 6073 /** 6074 * -------------------------------------------------------------------------- 6075 * Bootstrap (v5.1.3): util/index.js 6076 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6077 * -------------------------------------------------------------------------- 6078 */ 6079 const MILLISECONDS_MULTIPLIER = 1000; 6080 const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp) 6081 6082 const toType = obj => { 6083 if (obj === null || obj === undefined) { 6084 return `${obj}`; 6085 } 6086 6087 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 6088 }; 6089 6090 const getSelector = element => { 6091 let selector = element.getAttribute('data-bs-target'); 6092 6093 if (!selector || selector === '#') { 6094 let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes, 6095 // so everything starting with `#` or `.`. If a "real" URL is used as the selector, 6096 // `document.querySelector` will rightfully complain it is invalid. 6097 // See https://github.com/twbs/bootstrap/issues/32273 6098 6099 if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) { 6100 return null; 6101 } // Just in case some CMS puts out a full URL with the anchor appended 6102 6103 6104 if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) { 6105 hrefAttr = `#${hrefAttr.split('#')[1]}`; 6106 } 6107 6108 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null; 6109 } 6110 6111 return selector; 6112 }; 6113 6114 const getElementFromSelector = element => { 6115 const selector = getSelector(element); 6116 return selector ? document.querySelector(selector) : null; 6117 }; 6118 6119 const getTransitionDurationFromElement = element => { 6120 if (!element) { 6121 return 0; 6122 } // Get transition-duration of the element 6123 6124 6125 let { 6126 transitionDuration, 6127 transitionDelay 6128 } = window.getComputedStyle(element); 6129 const floatTransitionDuration = Number.parseFloat(transitionDuration); 6130 const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found 6131 6132 if (!floatTransitionDuration && !floatTransitionDelay) { 6133 return 0; 6134 } // If multiple durations are defined, take the first 6135 6136 6137 transitionDuration = transitionDuration.split(',')[0]; 6138 transitionDelay = transitionDelay.split(',')[0]; 6139 return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; 6140 }; 6141 6142 const triggerTransitionEnd = element => { 6143 element.dispatchEvent(new Event(TRANSITION_END)); 6144 }; 6145 6146 const isElement = obj => { 6147 if (!obj || typeof obj !== 'object') { 6148 return false;
6149 } 6150 6151 if (typeof obj.jquery !== 'undefined') { 6152 obj = obj[0]; 6153 } 6154 6155 return typeof obj.nodeType !== 'undefined'; 6156 }; 6157 6158 const getElement = obj => { 6159 if (isElement(obj)) { 6160 // it's a jQuery object or a node element 6161 return obj.jquery ? obj[0] : obj; 6162 } 6163 6164 if (typeof obj === 'string' && obj.length > 0) { 6165 return document.querySelector(obj); 6166 } 6167 6168 return null; 6169 }; 6170 6171 const typeCheckConfig = (componentName, config, configTypes) => { 6172 Object.keys(configTypes).forEach(property => { 6173 const expectedTypes = configTypes[property]; 6174 const value = config[property]; 6175 const valueType = value && isElement(value) ? 'element' : toType(value); 6176 6177 if (!new RegExp(expectedTypes).test(valueType)) { 6178 throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); 6179 } 6180 }); 6181 }; 6182 6183 const isVisible = element => { 6184 if (!isElement(element) || element.getClientRects().length === 0) { 6185 return false; 6186 } 6187 6188 return getComputedStyle(element).getPropertyValue('visibility') === 'visible'; 6189 }; 6190 6191 const isDisabled = element => { 6192 if (!element || element.nodeType !== Node.ELEMENT_NODE) { 6193 return true; 6194 } 6195 6196 if (element.classList.contains('disabled')) { 6197 return true; 6198 } 6199 6200 if (typeof element.disabled !== 'undefined') { 6201 return element.disabled; 6202 } 6203 6204 return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'; 6205 }; 6206 /** 6207 * Trick to restart an element's animation 6208 * 6209 * @param {HTMLElement} element 6210 * @return void 6211 * 6212 * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation 6213 */ 6214 6215 6216 const reflow = element => { 6217 // eslint-disable-next-line no-unused-expressions 6218 element.offsetHeight; 6219 }; 6220 6221 const getjQuery = () => { 6222 const { 6223 jQuery 6224 } = window; 6225 6226 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 6227 return jQuery; 6228 } 6229 6230 return null; 6231 }; 6232 6233 const DOMContentLoadedCallbacks = []; 6234 6235 const onDOMContentLoaded = callback => { 6236 if (document.readyState === 'loading') { 6237 // add listener on the first call when the document is in loading state 6238 if (!DOMContentLoadedCallbacks.length) { 6239 document.addEventListener('DOMContentLoaded', () => { 6240 DOMContentLoadedCallbacks.forEach(callback => callback()); 6241 }); 6242 } 6243 6244 DOMContentLoadedCallbacks.push(callback); 6245 } else { 6246 callback(); 6247 } 6248 }; 6249 6250 const defineJQueryPlugin = plugin => { 6251 onDOMContentLoaded(() => { 6252 const $ = getjQuery(); 6253 /* istanbul ignore if */ 6254 6255 if ($) { 6256 const name = plugin.NAME; 6257 const JQUERY_NO_CONFLICT = $.fn[name]; 6258 $.fn[name] = plugin.jQueryInterface; 6259 $.fn[name].Constructor = plugin; 6260 6261 $.fn[name].noConflict = () => { 6262 $.fn[name] = JQUERY_NO_CONFLICT; 6263 return plugin.jQueryInterface; 6264 }; 6265 } 6266 }); 6267 }; 6268 6269 const execute = callback => { 6270 if (typeof callback === 'function') { 6271 callback(); 6272 } 6273 }; 6274 6275 const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => { 6276 if (!waitForTransition) { 6277 execute(callback); 6278 return; 6279 } 6280 6281 const durationPadding = 5; 6282 const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding; 6283 let called = false; 6284 6285 const handler = ({ 6286 target 6287 }) => { 6288 if (target !== transitionElement) { 6289 return; 6290 } 6291 6292 called = true; 6293 transitionElement.removeEventListener(TRANSITION_END, handler); 6294 execute(callback); 6295 }; 6296 6297 transitionElement.addEventListener(TRANSITION_END, handler); 6298 setTimeout(() => { 6299 if (!called) { 6300 triggerTransitionEnd(transitionElement); 6301 } 6302 }, emulatedDuration); 6303 }; 6304 6305 /** 6306 * -------------------------------------------------------------------------- 6307 * Bootstrap (v5.1.3): util/scrollBar.js 6308 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6309 * -------------------------------------------------------------------------- 6310 */ 6311 const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'; 6312 const SELECTOR_STICKY_CONTENT = '.sticky-top'; 6313 6314 class ScrollBarHelper { 6315 constructor() { 6316 this._element = document.body; 6317 } 6318 6319 getWidth() { 6320 // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes 6321 const documentWidth = document.documentElement.clientWidth; 6322 return Math.abs(window.innerWidth - documentWidth); 6323 } 6324 6325 hide() { 6326 const width = this.getWidth(); 6327 6328 this._disableOverFlow(); // give padding to element to balance the hidden scrollbar width 6329 6330 6331 this._setElementAttributes(this._element, 'paddingRight', calculatedValue => calculatedValue + width);
6331 // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth 6332 6333 6334 this._setElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight', calculatedValue => calculatedValue + width); 6335 6336 this._setElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight', calculatedValue => calculatedValue - width); 6337 } 6338 6339 _disableOverFlow() { 6340 this._saveInitialAttribute(this._element, 'overflow'); 6341 6342 this._element.style.overflow = 'hidden'; 6343 } 6344 6345 _setElementAttributes(selector, styleProp, callback) { 6346 const scrollbarWidth = this.getWidth(); 6347 6348 const manipulationCallBack = element => { 6349 if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) { 6350 return; 6351 } 6352 6353 this._saveInitialAttribute(element, styleProp); 6354 6355 const calculatedValue = window.getComputedStyle(element)[styleProp]; 6356 element.style[styleProp] = `${callback(Number.parseFloat(calculatedValue))}px`; 6357 }; 6358 6359 this._applyManipulationCallback(selector, manipulationCallBack); 6360 } 6361 6362 reset() { 6363 this._resetElementAttributes(this._element, 'overflow'); 6364 6365 this._resetElementAttributes(this._element, 'paddingRight'); 6366 6367 this._resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight'); 6368 6369 this._resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight'); 6370 } 6371 6372 _saveInitialAttribute(element, styleProp) { 6373 const actualValue = element.style[styleProp]; 6374 6375 if (actualValue) { 6376 Manipulator__default.default.setDataAttribute(element, styleProp, actualValue); 6377 } 6378 } 6379 6380 _resetElementAttributes(selector, styleProp) { 6381 const manipulationCallBack = element => { 6382 const value = Manipulator__default.default.getDataAttribute(element, styleProp); 6383 6384 if (typeof value === 'undefined') { 6385 element.style.removeProperty(styleProp); 6386 } else { 6387 Manipulator__default.default.removeDataAttribute(element, styleProp); 6388 element.style[styleProp] = value; 6389 } 6390 }; 6391 6392 this._applyManipulationCallback(selector, manipulationCallBack); 6393 } 6394 6395 _applyManipulationCallback(selector, callBack) { 6396 if (isElement(selector)) { 6397 callBack(selector); 6398 } else { 6399 SelectorEngine__default.default.find(selector, this._element).forEach(callBack); 6400 } 6401 } 6402 6403 isOverflowing() { 6404 return this.getWidth() > 0; 6405 } 6406 6407 } 6408 6409 /** 6410 * -------------------------------------------------------------------------- 6411 * Bootstrap (v5.1.3): util/backdrop.js 6412 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6413 * -------------------------------------------------------------------------- 6414 */ 6415 const Default$2 = { 6416 className: 'modal-backdrop', 6417 isVisible: true, 6418 // if false, we use the backdrop helper without adding any element to the dom 6419 isAnimated: false, 6420 rootElement: 'body', 6421 // give the choice to place backdrop under different elements 6422 clickCallback: null 6423 }; 6424 const DefaultType$2 = { 6425 className: 'string', 6426 isVisible: 'boolean', 6427 isAnimated: 'boolean', 6428 rootElement: '(element|string)', 6429 clickCallback: '(function|null)' 6430 }; 6431 const NAME$2 = 'backdrop'; 6432 const CLASS_NAME_FADE = 'fade'; 6433 const CLASS_NAME_SHOW$1 = 'show'; 6434 const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$2}`; 6435 6436 class Backdrop { 6437 constructor(config) { 6438 this._config = this._getConfig(config); 6439 this._isAppended = false; 6440 this._element = null; 6441 } 6442 6443 show(callback) { 6444 if (!this._config.isVisible) { 6445 execute(callback); 6446 return; 6447 } 6448 6449 this._append(); 6450 6451 if (this._config.isAnimated) { 6452 reflow(this._getElement()); 6453 } 6454 6455 this._getElement().classList.add(CLASS_NAME_SHOW$1); 6456 6457 this._emulateAnimation(() => { 6458 execute(callback); 6459 }); 6460 } 6461 6462 hide(callback) { 6463 if (!this._config.isVisible) { 6464 execute(callback); 6465 return; 6466 } 6467 6468 this._getElement().classList.remove(CLASS_NAME_SHOW$1); 6469 6470 this._emulateAnimation(() => { 6471 this.dispose(); 6472 execute(callback); 6473 }); 6474 } // Private 6475 6476 6477 _getElement() { 6478 if (!this._element) { 6479 const backdrop = document.createElement('div'); 6480 backdrop.className = this._config.className; 6481 6482 if (this._config.isAnimated) { 6483 backdrop.classList.add(CLASS_NAME_FADE); 6484 } 6485 6486 this._element = backdrop; 6487 } 6488 6489 return this._element; 6490 } 6491 6492 _getConfig(config) { 6493 config = { ...Default$2, 6494 ...(typeof config === 'object' ? config : {}) 6495 }; // use getElement() with the default "body" to get a fresh Element on each instantiation 6496 6497 config.rootElement = getElement(config.rootElement); 6498 typeCheckConfig(NAME$2, config, DefaultType$2); 6499 return config; 6500 } 6501 6502 _append() { 6503 if (this._isAppended) { 6504 return; 6505 } 6506 6507 this._config.rootElement.append(this._getElement()); 6508 6509 EventHandler__default.default.on(this._getElement(), EVENT_MOUSEDOWN, () => { 6510 execute(this._config.clickCallback); 6511 }); 6512 this._isAppended = true; 6513 } 6514 6515 dispose() { 6516 if (!this._isAppended) { 6517 return; 6518 } 6519 6520 EventHandler__default.default.off(this._element, EVENT_MOUSEDOWN); 6521 6522 this._element.remove(); 6523 6524 this._isAppended = false;
6525 } 6526 6527 _emulateAnimation(callback) { 6528 executeAfterTransition(callback, this._getElement(), this._config.isAnimated); 6529 } 6530 6531 } 6532 6533 /** 6534 * -------------------------------------------------------------------------- 6535 * Bootstrap (v5.1.3): util/focustrap.js 6536 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6537 * -------------------------------------------------------------------------- 6538 */ 6539 const Default$1 = { 6540 trapElement: null, 6541 // The element to trap focus inside of 6542 autofocus: true 6543 }; 6544 const DefaultType$1 = { 6545 trapElement: 'element', 6546 autofocus: 'boolean' 6547 }; 6548 const NAME$1 = 'focustrap'; 6549 const DATA_KEY$1 = 'bs.focustrap'; 6550 const EVENT_KEY$1 = `.${DATA_KEY$1}`; 6551 const EVENT_FOCUSIN = `focusin${EVENT_KEY$1}`; 6552 const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$1}`; 6553 const TAB_KEY = 'Tab'; 6554 const TAB_NAV_FORWARD = 'forward'; 6555 const TAB_NAV_BACKWARD = 'backward'; 6556 6557 class FocusTrap { 6558 constructor(config) { 6559 this._config = this._getConfig(config); 6560 this._isActive = false; 6561 this._lastTabNavDirection = null; 6562 } 6563 6564 activate() { 6565 const { 6566 trapElement, 6567 autofocus 6568 } = this._config; 6569 6570 if (this._isActive) { 6571 return; 6572 } 6573 6574 if (autofocus) { 6575 trapElement.focus(); 6576 } 6577 6578 EventHandler__default.default.off(document, EVENT_KEY$1); // guard against infinite focus loop 6579 6580 EventHandler__default.default.on(document, EVENT_FOCUSIN, event => this._handleFocusin(event)); 6581 EventHandler__default.default.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event)); 6582 this._isActive = true; 6583 } 6584 6585 deactivate() { 6586 if (!this._isActive) { 6587 return; 6588 } 6589 6590 this._isActive = false; 6591 EventHandler__default.default.off(document, EVENT_KEY$1); 6592 } // Private 6593 6594 6595 _handleFocusin(event) { 6596 const { 6597 target 6598 } = event; 6599 const { 6600 trapElement 6601 } = this._config; 6602 6603 if (target === document || target === trapElement || trapElement.contains(target)) { 6604 return; 6605 } 6606 6607 const elements = SelectorEngine__default.default.focusableChildren(trapElement); 6608 6609 if (elements.length === 0) { 6610 trapElement.focus(); 6611 } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) { 6612 elements[elements.length - 1].focus(); 6613 } else { 6614 elements[0].focus(); 6615 } 6616 } 6617 6618 _handleKeydown(event) { 6619 if (event.key !== TAB_KEY) { 6620 return; 6621 } 6622 6623 this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD; 6624 } 6625 6626 _getConfig(config) { 6627 config = { ...Default$1, 6628 ...(typeof config === 'object' ? config : {}) 6629 }; 6630 typeCheckConfig(NAME$1, config, DefaultType$1); 6631 return config; 6632 } 6633 6634 } 6635 6636 /** 6637 * -------------------------------------------------------------------------- 6638 * Bootstrap (v5.1.3): util/component-functions.js 6639 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6640 * -------------------------------------------------------------------------- 6641 */ 6642 6643 const enableDismissTrigger = (component, method = 'hide') => { 6644 const clickEvent = `click.dismiss${component.EVENT_KEY}`; 6645 const name = component.NAME; 6646 EventHandler__default.default.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) { 6647 if (['A', 'AREA'].includes(this.tagName)) { 6648 event.preventDefault(); 6649 } 6650 6651 if (isDisabled(this)) { 6652 return; 6653 } 6654 6655 const target = getElementFromSelector(this) || this.closest(`.${name}`); 6656 const instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method 6657 6658 instance[method](); 6659 }); 6660 }; 6661 6662 /** 6663 * -------------------------------------------------------------------------- 6664 * Bootstrap (v5.1.3): offcanvas.js 6665 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6666 * -------------------------------------------------------------------------- 6667 */ 6668 /** 6669 * ------------------------------------------------------------------------ 6670 * Constants 6671 * ------------------------------------------------------------------------ 6672 */ 6673 6674 const NAME = 'offcanvas'; 6675 const DATA_KEY = 'bs.offcanvas'; 6676 const EVENT_KEY = `.${DATA_KEY}`; 6677 const DATA_API_KEY = '.data-api'; 6678 const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`; 6679 const ESCAPE_KEY = 'Escape'; 6680 const Default = { 6681 backdrop: true, 6682 keyboard: true, 6683 scroll: false 6684 }; 6685 const DefaultType = { 6686 backdrop: 'boolean', 6687 keyboard: 'boolean', 6688 scroll: 'boolean' 6689 }; 6690 const CLASS_NAME_SHOW = 'show'; 6691 const CLASS_NAME_BACKDROP = 'offcanvas-backdrop'; 6692 const OPEN_SELECTOR = '.offcanvas.show'; 6693 const EVENT_SHOW = `show${EVENT_KEY}`; 6694 const EVENT_SHOWN = `shown${EVENT_KEY}`; 6695 const EVENT_HIDE = `hide${EVENT_KEY}`; 6696 const EVENT_HIDDEN = `hidden${EVENT_KEY}`; 6697 const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`; 6698 const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY}`; 6699 const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="offcanvas"]'; 6700 /** 6701 * ------------------------------------------------------------------------ 6702 * Class Definition 6703 * ------------------------------------------------------------------------ 6704 */ 6705 6706 class Offcanvas extends BaseComponent__default.default { 6707 constructor(element, config) { 6708 super(element); 6709 this._config = this._getConfig(config); 6710 this._isShown = false;
6711 this._backdrop = this._initializeBackDrop(); 6712 this._focustrap = this._initializeFocusTrap(); 6713 6714 this._addEventListeners(); 6715 } // Getters 6716 6717 6718 static get NAME() { 6719 return NAME; 6720 } 6721 6722 static get Default() { 6723 return Default; 6724 } // Public 6725 6726 6727 toggle(relatedTarget) { 6728 return this._isShown ? this.hide() : this.show(relatedTarget); 6729 } 6730 6731 show(relatedTarget) { 6732 if (this._isShown) { 6733 return; 6734 } 6735 6736 const showEvent = EventHandler__default.default.trigger(this._element, EVENT_SHOW, { 6737 relatedTarget 6738 }); 6739 6740 if (showEvent.defaultPrevented) { 6741 return; 6742 } 6743 6744 this._isShown = true; 6745 this._element.style.visibility = 'visible'; 6746 6747 this._backdrop.show(); 6748 6749 if (!this._config.scroll) { 6750 new ScrollBarHelper().hide(); 6751 } 6752 6753 this._element.removeAttribute('aria-hidden'); 6754 6755 this._element.setAttribute('aria-modal', true); 6756 6757 this._element.setAttribute('role', 'dialog'); 6758 6759 this._element.classList.add(CLASS_NAME_SHOW); 6760 6761 const completeCallBack = () => { 6762 if (!this._config.scroll) { 6763 this._focustrap.activate(); 6764 } 6765 6766 EventHandler__default.default.trigger(this._element, EVENT_SHOWN, { 6767 relatedTarget 6768 }); 6769 }; 6770 6771 this._queueCallback(completeCallBack, this._element, true); 6772 } 6773 6774 hide() { 6775 if (!this._isShown) { 6776 return; 6777 } 6778 6779 const hideEvent = EventHandler__default.default.trigger(this._element, EVENT_HIDE); 6780 6781 if (hideEvent.defaultPrevented) { 6782 return; 6783 } 6784 6785 this._focustrap.deactivate(); 6786 6787 this._element.blur(); 6788 6789 this._isShown = false; 6790 6791 this._element.classList.remove(CLASS_NAME_SHOW); 6792 6793 this._backdrop.hide(); 6794 6795 const completeCallback = () => { 6796 this._element.setAttribute('aria-hidden', true); 6797 6798 this._element.removeAttribute('aria-modal'); 6799 6800 this._element.removeAttribute('role'); 6801 6802 this._element.style.visibility = 'hidden'; 6803 6804 if (!this._config.scroll) { 6805 new ScrollBarHelper().reset(); 6806 } 6807 6808 EventHandler__default.default.trigger(this._element, EVENT_HIDDEN); 6809 }; 6810 6811 this._queueCallback(completeCallback, this._element, true); 6812 } 6813 6814 dispose() { 6815 this._backdrop.dispose(); 6816 6817 this._focustrap.deactivate(); 6818 6819 super.dispose(); 6820 } // Private 6821 6822 6823 _getConfig(config) { 6824 config = { ...Default, 6825 ...Manipulator__default.default.getDataAttributes(this._element), 6826 ...(typeof config === 'object' ? config : {}) 6827 }; 6828 typeCheckConfig(NAME, config, DefaultType); 6829 return config; 6830 } 6831 6832 _initializeBackDrop() { 6833 return new Backdrop({ 6834 className: CLASS_NAME_BACKDROP, 6835 isVisible: this._config.backdrop, 6836 isAnimated: true, 6837 rootElement: this._element.parentNode, 6838 clickCallback: () => this.hide() 6839 }); 6840 } 6841 6842 _initializeFocusTrap() { 6843 return new FocusTrap({ 6844 trapElement: this._element 6845 }); 6846 } 6847 6848 _addEventListeners() { 6849 EventHandler__default.default.on(this._element, EVENT_KEYDOWN_DISMISS, event => { 6850 if (this._config.keyboard && event.key === ESCAPE_KEY) { 6851 this.hide(); 6852 } 6853 }); 6854 } // Static 6855 6856 6857 static jQueryInterface(config) { 6858 return this.each(function () { 6859 const data = Offcanvas.getOrCreateInstance(this, config); 6860 6861 if (typeof config !== 'string') { 6862 return; 6863 } 6864 6865 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 6866 throw new TypeError(`No method named "${config}"`); 6867 } 6868 6869 data[config](this); 6870 }); 6871 } 6872 6873 } 6874 /** 6875 * ------------------------------------------------------------------------ 6876 * Data Api implementation 6877 * ------------------------------------------------------------------------ 6878 */ 6879 6880 6881 EventHandler__default.default.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { 6882 const target = getElementFromSelector(this); 6883 6884 if (['A', 'AREA'].includes(this.tagName)) { 6885 event.preventDefault(); 6886 } 6887 6888 if (isDisabled(this)) { 6889 return; 6890 } 6891 6892 EventHandler__default.default.one(target, EVENT_HIDDEN, () => { 6893 // focus on trigger when it is closed 6894 if (isVisible(this)) { 6895 this.focus(); 6896 } 6897 }); // avoid conflict when clicking a toggler of an offcanvas, while another is open 6898 6899 const allReadyOpen = SelectorEngine__default.default.findOne(OPEN_SELECTOR); 6900 6901 if (allReadyOpen && allReadyOpen !== target) { 6902 Offcanvas.getInstance(allReadyOpen).hide(); 6903 } 6904 6905 const data = Offcanvas.getOrCreateInstance(target); 6906 data.toggle(this); 6907 }); 6908 EventHandler__default.default.on(window, EVENT_LOAD_DATA_API, () =>
6908 SelectorEngine__default.default.find(OPEN_SELECTOR).forEach(el => Offcanvas.getOrCreateInstance(el).show())); 6909 enableDismissTrigger(Offcanvas); 6910 /** 6911 * ------------------------------------------------------------------------ 6912 * jQuery 6913 * ------------------------------------------------------------------------ 6914 */ 6915 6916 defineJQueryPlugin(Offcanvas); 6917 6918 return Offcanvas; 6919 6920 })); 6921 6922 }(offcanvas$1)); 6923 6924 var offcanvas = offcanvas$1.exports; 6925 6926 var popover$1 = {exports: {}}; 6927 6928 var tooltip$1 = {exports: {}}; 6929 6930 /*! 6931 * Bootstrap tooltip.js v5.1.3 (https://getbootstrap.com/) 6932 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 6933 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6934 */ 6935 6936 (function (module, exports) { 6937 (function (global, factory) { 6938 module.exports = factory(require$$0, data.exports, eventHandler.exports, manipulator.exports, selectorEngine.exports, baseComponent.exports) ; 6939 })(commonjsGlobal, (function (Popper, Data, EventHandler, Manipulator, SelectorEngine, BaseComponent) { 6940 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 6941 6942 function _interopNamespace(e) { 6943 if (e && e.__esModule) return e; 6944 const n = Object.create(null); 6945 if (e) { 6946 for (const k in e) { 6947 if (k !== 'default') { 6948 const d = Object.getOwnPropertyDescriptor(e, k); 6949 Object.defineProperty(n, k, d.get ? d : { 6950 enumerable: true, 6951 get: () => e[k] 6952 }); 6953 } 6954 } 6955 } 6956 n.default = e; 6957 return Object.freeze(n); 6958 } 6959 6960 const Popper__namespace = /*#__PURE__*/_interopNamespace(Popper); 6961 const Data__default = /*#__PURE__*/_interopDefaultLegacy(Data); 6962 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 6963 const Manipulator__default = /*#__PURE__*/_interopDefaultLegacy(Manipulator); 6964 const SelectorEngine__default = /*#__PURE__*/_interopDefaultLegacy(SelectorEngine); 6965 const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); 6966 6967 /** 6968 * -------------------------------------------------------------------------- 6969 * Bootstrap (v5.1.3): util/index.js 6970 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6971 * -------------------------------------------------------------------------- 6972 */ 6973 const MAX_UID = 1000000; 6974 6975 const toType = obj => { 6976 if (obj === null || obj === undefined) { 6977 return `${obj}`; 6978 } 6979 6980 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 6981 }; 6982 /** 6983 * -------------------------------------------------------------------------- 6984 * Public Util Api 6985 * -------------------------------------------------------------------------- 6986 */ 6987 6988 6989 const getUID = prefix => { 6990 do { 6991 prefix += Math.floor(Math.random() * MAX_UID); 6992 } while (document.getElementById(prefix)); 6993 6994 return prefix; 6995 }; 6996 6997 const isElement = obj => { 6998 if (!obj || typeof obj !== 'object') { 6999 return false; 7000 } 7001 7002 if (typeof obj.jquery !== 'undefined') { 7003 obj = obj[0]; 7004 } 7005 7006 return typeof obj.nodeType !== 'undefined'; 7007 }; 7008 7009 const getElement = obj => { 7010 if (isElement(obj)) { 7011 // it's a jQuery object or a node element 7012 return obj.jquery ? obj[0] : obj; 7013 } 7014 7015 if (typeof obj === 'string' && obj.length > 0) { 7016 return document.querySelector(obj); 7017 } 7018 7019 return null; 7020 }; 7021 7022 const typeCheckConfig = (componentName, config, configTypes) => { 7023 Object.keys(configTypes).forEach(property => { 7024 const expectedTypes = configTypes[property]; 7025 const value = config[property]; 7026 const valueType = value && isElement(value) ? 'element' : toType(value); 7027 7028 if (!new RegExp(expectedTypes).test(valueType)) { 7029 throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); 7030 } 7031 }); 7032 }; 7033 7034 const findShadowRoot = element => { 7035 if (!document.documentElement.attachShadow) { 7036 return null; 7037 } // Can find the shadow root otherwise it'll return the document 7038 7039 7040 if (typeof element.getRootNode === 'function') { 7041 const root = element.getRootNode(); 7042 return root instanceof ShadowRoot ? root : null; 7043 } 7044 7045 if (element instanceof ShadowRoot) { 7046 return element; 7047 } // when we don't find a shadow root 7048 7049 7050 if (!element.parentNode) { 7051 return null; 7052 } 7053 7054 return findShadowRoot(element.parentNode); 7055 }; 7056 7057 const noop = () => {}; 7058 7059 const getjQuery = () => { 7060 const { 7061 jQuery 7062 } = window; 7063 7064 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 7065 return jQuery; 7066 } 7067 7068 return null; 7069 }; 7070 7071 const DOMContentLoadedCallbacks = []; 7072 7073 const onDOMContentLoaded = callback => { 7074 if (document.readyState === 'loading') { 7075 // add listener on the first call when the document is in loading state 7076 if (!DOMContentLoadedCallbacks.length) { 7077 document.addEventListener('DOMContentLoaded', () => { 7078 DOMContentLoadedCallbacks.forEach(callback => callback()); 7079 }); 7080 } 7081 7082 DOMContentLoadedCallbacks.push(callback); 7083 } else { 7084 callback(); 7085 } 7086 }; 7087 7088 const isRTL = () => document.documentElement.dir === 'rtl'; 7089 7090 const defineJQueryPlugin = plugin => { 7091 onDOMContentLoaded(() => { 7092 const $ = getjQuery(); 7093 /* istanbul ignore if */ 7094 7095 if ($) { 7096 const name = plugin.NAME; 7097 const JQUERY_NO_CONFLICT = $.fn[name]; 7098 $.fn[name] = plugin.jQueryInterface; 7099 $.fn[name].Constructor = plugin; 7100 7101 $.fn[name].noConflict = () => { 7102 $.fn[name] = JQUERY_NO_CONFLICT; 7103 return plugin.jQueryInterface; 7104 }; 7105 } 7106 }); 7107 }; 7108 7109 /** 7110 * -------------------------------------------------------------------------- 7111 * Bootstrap (v5.1.3): util/sanitizer.js 7112 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 7113 * -------------------------------------------------------------------------- 7114 */ 7115 const uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']); 7116 const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i; 7117 /** 7118 * A pattern that recognizes a commonly useful subset of URLs that are safe. 7119 * 7120 * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts 7121 */ 7122 7123 const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i; 7124 /** 7125 * A pattern that matches safe data URLs. Only matches image, video and audio types. 7126 * 7127 * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts 7128 */ 7129 7130 const DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i; 7131 7132 const allowedAttribute = (attribute, allowedAttributeList) => {
7133 const attributeName = attribute.nodeName.toLowerCase(); 7134 7135 if (allowedAttributeList.includes(attributeName)) { 7136 if (uriAttributes.has(attributeName)) { 7137 return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue) || DATA_URL_PATTERN.test(attribute.nodeValue)); 7138 } 7139 7140 return true; 7141 } 7142 7143 const regExp = allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp); // Check if a regular expression validates the attribute. 7144 7145 for (let i = 0, len = regExp.length; i < len; i++) { 7146 if (regExp[i].test(attributeName)) { 7147 return true; 7148 } 7149 } 7150 7151 return false; 7152 }; 7153 7154 const DefaultAllowlist = { 7155 // Global attributes allowed on any supplied element below. 7156 '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN], 7157 a: ['target', 'href', 'title', 'rel'], 7158 area: [], 7159 b: [], 7160 br: [], 7161 col: [], 7162 code: [], 7163 div: [], 7164 em: [], 7165 hr: [], 7166 h1: [], 7167 h2: [], 7168 h3: [], 7169 h4: [], 7170 h5: [], 7171 h6: [], 7172 i: [], 7173 img: ['src', 'srcset', 'alt', 'title', 'width', 'height'], 7174 li: [], 7175 ol: [], 7176 p: [], 7177 pre: [], 7178 s: [], 7179 small: [], 7180 span: [], 7181 sub: [], 7182 sup: [], 7183 strong: [], 7184 u: [], 7185 ul: [] 7186 }; 7187 function sanitizeHtml(unsafeHtml, allowList, sanitizeFn) { 7188 if (!unsafeHtml.length) { 7189 return unsafeHtml; 7190 } 7191 7192 if (sanitizeFn && typeof sanitizeFn === 'function') { 7193 return sanitizeFn(unsafeHtml); 7194 } 7195 7196 const domParser = new window.DOMParser(); 7197 const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); 7198 const elements = [].concat(...createdDocument.body.querySelectorAll('*')); 7199 7200 for (let i = 0, len = elements.length; i < len; i++) { 7201 const element = elements[i]; 7202 const elementName = element.nodeName.toLowerCase(); 7203 7204 if (!Object.keys(allowList).includes(elementName)) { 7205 element.remove(); 7206 continue; 7207 } 7208 7209 const attributeList = [].concat(...element.attributes); 7210 const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []); 7211 attributeList.forEach(attribute => { 7212 if (!allowedAttribute(attribute, allowedAttributes)) { 7213 element.removeAttribute(attribute.nodeName); 7214 } 7215 }); 7216 } 7217 7218 return createdDocument.body.innerHTML; 7219 } 7220 7221 /** 7222 * -------------------------------------------------------------------------- 7223 * Bootstrap (v5.1.3): tooltip.js 7224 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 7225 * -------------------------------------------------------------------------- 7226 */ 7227 /** 7228 * ------------------------------------------------------------------------ 7229 * Constants 7230 * ------------------------------------------------------------------------ 7231 */ 7232 7233 const NAME = 'tooltip'; 7234 const DATA_KEY = 'bs.tooltip'; 7235 const EVENT_KEY = `.${DATA_KEY}`; 7236 const CLASS_PREFIX = 'bs-tooltip'; 7237 const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']); 7238 const DefaultType = { 7239 animation: 'boolean', 7240 template: 'string', 7241 title: '(string|element|function)', 7242 trigger: 'string', 7243 delay: '(number|object)', 7244 html: 'boolean', 7245 selector: '(string|boolean)', 7246 placement: '(string|function)', 7247 offset: '(array|string|function)', 7248 container: '(string|element|boolean)', 7249 fallbackPlacements: 'array', 7250 boundary: '(string|element)', 7251 customClass: '(string|function)', 7252 sanitize: 'boolean', 7253 sanitizeFn: '(null|function)', 7254 allowList: 'object', 7255 popperConfig: '(null|object|function)' 7256 }; 7257 const AttachmentMap = { 7258 AUTO: 'auto', 7259 TOP: 'top', 7260 RIGHT: isRTL() ? 'left' : 'right', 7261 BOTTOM: 'bottom', 7262 LEFT: isRTL() ? 'right' : 'left' 7263 }; 7264 const Default = { 7265 animation: true, 7266 template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>', 7267 trigger: 'hover focus', 7268 title: '', 7269 delay: 0, 7270 html: false, 7271 selector: false, 7272 placement: 'top', 7273 offset: [0, 0], 7274 container: false, 7275 fallbackPlacements: ['top', 'right', 'bottom', 'left'], 7276 boundary: 'clippingParents', 7277 customClass: '', 7278 sanitize: true, 7279 sanitizeFn: null, 7280 allowList: DefaultAllowlist, 7281 popperConfig: null 7282 }; 7283 const Event = { 7284 HIDE: `hide${EVENT_KEY}`, 7285 HIDDEN: `hidden${EVENT_KEY}`, 7286 SHOW: `show${EVENT_KEY}`, 7287 SHOWN: `shown${EVENT_KEY}`, 7288 INSERTED: `inserted${EVENT_KEY}`, 7289 CLICK: `click${EVENT_KEY}`, 7290 FOCUSIN: `focusin${EVENT_KEY}`, 7291 FOCUSOUT: `focusout${EVENT_KEY}`, 7292 MOUSEENTER: `mouseenter${EVENT_KEY}`, 7293 MOUSELEAVE: `mouseleave${EVENT_KEY}` 7294 }; 7295 const CLASS_NAME_FADE = 'fade'; 7296 const CLASS_NAME_MODAL = 'modal'; 7297 const CLASS_NAME_SHOW = 'show'; 7298 const HOVER_STATE_SHOW = 'show'; 7299 const HOVER_STATE_OUT = 'out'; 7300 const SELECTOR_TOOLTIP_INNER = '.tooltip-inner'; 7301 const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`; 7302 const EVENT_MODAL_HIDE = 'hide.bs.modal'; 7303 const TRIGGER_HOVER = 'hover'; 7304 const TRIGGER_FOCUS = 'focus'; 7305 const TRIGGER_CLICK = 'click'; 7306 const TRIGGER_MANUAL = 'manual'; 7307 /** 7308 * ------------------------------------------------------------------------ 7309 * Class Definition 7310 * ------------------------------------------------------------------------ 7311 */ 7312 7313 class Tooltip extends BaseComponent__default.default { 7314 constructor(element, config) { 7315 if (typeof Popper__namespace === 'undefined') { 7316 throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)'); 7317 } 7318 7319 super(element); // private 7320 7321 this._isEnabled = true; 7322 this._timeout = 0; 7323 this._hoverState = ''; 7324 this._activeTrigger = {}; 7325 this._popper = null; // Protected 7326 7327 this._config = this._getConfig(config); 7328 this.tip = null; 7329 7330 this._setListeners(); 7331 } // Getters 7332 7333 7334 static get Default() { 7335 return Default; 7336 } 7337 7338 static get NAME() { 7339 return NAME; 7340 } 7341 7342 static get Event() { 7343 return Event; 7344 } 7345 7346 static get DefaultType() { 7347 return DefaultType; 7348 } // Public 7349 7350 7351 enable() { 7352 this._isEnabled = true; 7353 } 7354 7355 disable() { 7356 this._isEnabled = false;
7357 } 7358 7359 toggleEnabled() { 7360 this._isEnabled = !this._isEnabled; 7361 } 7362 7363 toggle(event) { 7364 if (!this._isEnabled) { 7365 return; 7366 } 7367 7368 if (event) { 7369 const context = this._initializeOnDelegatedTarget(event); 7370 7371 context._activeTrigger.click = !context._activeTrigger.click; 7372 7373 if (context._isWithActiveTrigger()) { 7374 context._enter(null, context); 7375 } else { 7376 context._leave(null, context); 7377 } 7378 } else { 7379 if (this.getTipElement().classList.contains(CLASS_NAME_SHOW)) { 7380 this._leave(null, this); 7381 7382 return; 7383 } 7384 7385 this._enter(null, this); 7386 } 7387 } 7388 7389 dispose() { 7390 clearTimeout(this._timeout); 7391 EventHandler__default.default.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler); 7392 7393 if (this.tip) { 7394 this.tip.remove(); 7395 } 7396 7397 this._disposePopper(); 7398 7399 super.dispose(); 7400 } 7401 7402 show() { 7403 if (this._element.style.display === 'none') { 7404 throw new Error('Please use show on visible elements'); 7405 } 7406 7407 if (!(this.isWithContent() && this._isEnabled)) { 7408 return; 7409 } 7410 7411 const showEvent = EventHandler__default.default.trigger(this._element, this.constructor.Event.SHOW); 7412 const shadowRoot = findShadowRoot(this._element); 7413 const isInTheDom = shadowRoot === null ? this._element.ownerDocument.documentElement.contains(this._element) : shadowRoot.contains(this._element); 7414 7415 if (showEvent.defaultPrevented || !isInTheDom) { 7416 return; 7417 } // A trick to recreate a tooltip in case a new title is given by using the NOT documented `data-bs-original-title` 7418 // This will be removed later in favor of a `setContent` method 7419 7420 7421 if (this.constructor.NAME === 'tooltip' && this.tip && this.getTitle() !== this.tip.querySelector(SELECTOR_TOOLTIP_INNER).innerHTML) { 7422 this._disposePopper(); 7423 7424 this.tip.remove(); 7425 this.tip = null; 7426 } 7427 7428 const tip = this.getTipElement(); 7429 const tipId = getUID(this.constructor.NAME);
7430 tip.setAttribute('id', tipId); 7431 7432 this._element.setAttribute('aria-describedby', tipId); 7433 7434 if (this._config.animation) { 7435 tip.classList.add(CLASS_NAME_FADE); 7436 } 7437 7438 const placement = typeof this._config.placement === 'function' ? this._config.placement.call(this, tip, this._element) : this._config.placement; 7439 7440 const attachment = this._getAttachment(placement); 7441 7442 this._addAttachmentClass(attachment); 7443 7444 const { 7445 container 7446 } = this._config; 7447 Data__default.default.set(tip, this.constructor.DATA_KEY, this); 7448 7449 if (!this._element.ownerDocument.documentElement.contains(this.tip)) { 7450 container.append(tip); 7451 EventHandler__default.default.trigger(this._element, this.constructor.Event.INSERTED); 7452 } 7453 7454 if (this._popper) { 7455 this._popper.update(); 7456 } else { 7457 this._popper = Popper__namespace.createPopper(this._element, tip, this._getPopperConfig(attachment)); 7458 } 7459 7460 tip.classList.add(CLASS_NAME_SHOW); 7461 7462 const customClass = this._resolvePossibleFunction(this._config.customClass); 7463 7464 if (customClass) { 7465 tip.classList.add(...customClass.split(' ')); 7466 } // If this is a touch-enabled device we add extra 7467 // empty mouseover listeners to the body's immediate children; 7468 // only needed because of broken event delegation on iOS 7469 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 7470 7471 7472 if ('ontouchstart' in document.documentElement) { 7473 [].concat(...document.body.children).forEach(element => { 7474 EventHandler__default.default.on(element, 'mouseover', noop); 7475 }); 7476 } 7477 7478 const complete = () => { 7479 const prevHoverState = this._hoverState; 7480 this._hoverState = null; 7481 EventHandler__default.default.trigger(this._element, this.constructor.Event.SHOWN); 7482 7483 if (prevHoverState === HOVER_STATE_OUT) { 7484 this._leave(null, this); 7485 } 7486 }; 7487 7488 const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE); 7489 7490 this._queueCallback(complete, this.tip, isAnimated); 7491 } 7492 7493 hide() { 7494 if (!this._popper) { 7495 return; 7496 } 7497 7498 const tip = this.getTipElement(); 7499 7500 const complete = () => { 7501 if (this._isWithActiveTrigger()) { 7502 return; 7503 } 7504 7505 if (this._hoverState !== HOVER_STATE_SHOW) { 7506 tip.remove(); 7507 } 7508 7509 this._cleanTipClass(); 7510 7511 this._element.removeAttribute('aria-describedby'); 7512 7513 EventHandler__default.default.trigger(this._element, this.constructor.Event.HIDDEN); 7514 7515 this._disposePopper(); 7516 }; 7517 7518 const hideEvent = EventHandler__default.default.trigger(this._element, this.constructor.Event.HIDE); 7519 7520 if (hideEvent.defaultPrevented) { 7521 return; 7522 } 7523 7524 tip.classList.remove(CLASS_NAME_SHOW); // If this is a touch-enabled device we remove the extra 7525 // empty mouseover listeners we added for iOS support 7526 7527 if ('ontouchstart' in document.documentElement) { 7528 [].concat(...document.body.children).forEach(element => EventHandler__default.default.off(element, 'mouseover', noop)); 7529 } 7530 7531 this._activeTrigger[TRIGGER_CLICK] = false; 7532 this._activeTrigger[TRIGGER_FOCUS] = false; 7533 this._activeTrigger[TRIGGER_HOVER] = false; 7534 const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE); 7535 7536 this._queueCallback(complete, this.tip, isAnimated); 7537 7538 this._hoverState = ''; 7539 } 7540 7541 update() { 7542 if (this._popper !== null) { 7543 this._popper.update(); 7544 } 7545 } // Protected 7546 7547 7548 isWithContent() { 7549 return Boolean(this.getTitle()); 7550 } 7551 7552 getTipElement() { 7553 if (this.tip) { 7554 return this.tip; 7555 } 7556 7557 const element = document.createElement('div'); 7558 element.innerHTML = this._config.template; 7559 const tip = element.children[0]; 7560 this.setContent(tip); 7561 tip.classList.remove(CLASS_NAME_FADE, CLASS_NAME_SHOW); 7562 this.tip = tip; 7563 return this.tip; 7564 } 7565 7566 setContent(tip) { 7567 this._sanitizeAndSetContent(tip, this.getTitle(), SELECTOR_TOOLTIP_INNER); 7568 } 7569 7570 _sanitizeAndSetContent(template, content, selector) { 7571 const templateElement = SelectorEngine__default.default.findOne(selector, template); 7572 7573 if (!content && templateElement) { 7574 templateElement.remove(); 7575 return; 7576 } // we use append for html objects to maintain js events 7577 7578 7579 this.setElementContent(templateElement, content); 7580 } 7581 7582 setElementContent(element, content) { 7583 if (element === null) { 7584 return; 7585 } 7586 7587 if (isElement(content)) { 7588 content = getElement(content); // content is a DOM node or a jQuery 7589 7590 if (this._config.html) { 7591 if (content.parentNode !== element) { 7592 element.innerHTML = ''; 7593 element.append(content); 7594 } 7595 } else { 7596 element.textContent = content.textContent; 7597 } 7598 7599 return; 7600 } 7601 7602 if (this._config.html) { 7603 if (this._config.sanitize) { 7604 content = sanitizeHtml(content, this._config.allowList, this._config.sanitizeFn); 7605 } 7606 7607 element.innerHTML = content; 7608 } else { 7609 element.textContent = content; 7610 } 7611 } 7612 7613 getTitle() { 7614 const title = this._element.getAttribute('data-bs-original-title') || this._config.title; 7615 7616 return this._resolvePossibleFunction(title); 7617 } 7618 7619 updateAttachment(attachment) { 7620 if (attachment === 'right') { 7621 return 'end'; 7622 } 7623 7624 if (attachment === 'left') { 7625 return 'start'; 7626 } 7627 7628 return attachment; 7629 } // Private 7630 7631 7632 _initializeOnDelegatedTarget(event, context) { 7633 return context || this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig()); 7634 } 7635 7636 _getOffset() { 7637 const { 7638 offset 7639 } = this._config; 7640 7641 if (typeof offset === 'string') { 7642 return offset.split(',').map(val => Number.parseInt(val, 10)); 7643 } 7644 7645 if (typeof offset === 'function') { 7646 return popperData => offset(popperData, this._element); 7647 } 7648 7649 return offset; 7650 } 7651 7652 _resolvePossibleFunction(content) { 7653 return typeof content === 'function' ? content.call(this._element) : content; 7654 } 7655 7656 _getPopperConfig(attachment) { 7657 const defaultBsPopperConfig = { 7658 placement: attachment, 7659 modifiers: [{ 7660 name: 'flip', 7661 options: { 7662 fallbackPlacements: this._config.fallbackPlacements 7663 } 7664 }, { 7665 name: 'offset', 7666 options: { 7667 offset: this._getOffset() 7668 } 7669 }, { 7670 name: 'preventOverflow', 7671 options: {
7672 boundary: this._config.boundary 7673 } 7674 }, { 7675 name: 'arrow', 7676 options: { 7677 element: `.${this.constructor.NAME}-arrow` 7678 } 7679 }, { 7680 name: 'onChange', 7681 enabled: true, 7682 phase: 'afterWrite', 7683 fn: data => this._handlePopperPlacementChange(data) 7684 }], 7685 onFirstUpdate: data => { 7686 if (data.options.placement !== data.placement) { 7687 this._handlePopperPlacementChange(data); 7688 } 7689 } 7690 }; 7691 return { ...defaultBsPopperConfig, 7692 ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig) 7693 }; 7694 } 7695 7696 _addAttachmentClass(attachment) { 7697 this.getTipElement().classList.add(`${this._getBasicClassPrefix()}-${this.updateAttachment(attachment)}`); 7698 } 7699 7700 _getAttachment(placement) { 7701 return AttachmentMap[placement.toUpperCase()]; 7702 } 7703 7704 _setListeners() { 7705 const triggers = this._config.trigger.split(' '); 7706 7707 triggers.forEach(trigger => { 7708 if (trigger === 'click') { 7709 EventHandler__default.default.on(this._element, this.constructor.Event.CLICK, this._config.selector, event => this.toggle(event)); 7710 } else if (trigger !== TRIGGER_MANUAL) { 7711 const eventIn = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSEENTER : this.constructor.Event.FOCUSIN; 7712 const eventOut = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSELEAVE : this.constructor.Event.FOCUSOUT; 7713 EventHandler__default.default.on(this._element, eventIn, this._config.selector, event => this._enter(event)); 7714 EventHandler__default.default.on(this._element, eventOut, this._config.selector, event => this._leave(event)); 7715 } 7716 }); 7717 7718 this._hideModalHandler = () => { 7719 if (this._element) { 7720 this.hide(); 7721 } 7722 }; 7723 7724 EventHandler__default.default.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler); 7725 7726 if (this._config.selector) { 7727 this._config = { ...this._config, 7728 trigger: 'manual', 7729 selector: '' 7730 }; 7731 } else { 7732 this._fixTitle(); 7733 } 7734 } 7735 7736 _fixTitle() { 7737 const title = this._element.getAttribute('title'); 7738 7739 const originalTitleType = typeof this._element.getAttribute('data-bs-original-title'); 7740 7741 if (title || originalTitleType !== 'string') { 7742 this._element.setAttribute('data-bs-original-title', title || ''); 7743 7744 if (title && !this._element.getAttribute('aria-label') && !this._element.textContent) { 7745 this._element.setAttribute('aria-label', title); 7746 } 7747 7748 this._element.setAttribute('title', ''); 7749 } 7750 } 7751 7752 _enter(event, context) { 7753 context = this._initializeOnDelegatedTarget(event, context); 7754 7755 if (event) { 7756 context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true; 7757 } 7758 7759 if (context.getTipElement().classList.contains(CLASS_NAME_SHOW) || context._hoverState === HOVER_STATE_SHOW) { 7760 context._hoverState = HOVER_STATE_SHOW; 7761 return; 7762 } 7763 7764 clearTimeout(context._timeout); 7765 context._hoverState = HOVER_STATE_SHOW; 7766 7767 if (!context._config.delay || !context._config.delay.show) { 7768 context.show(); 7769 return; 7770 } 7771 7772 context._timeout = setTimeout(() => { 7773 if (context._hoverState === HOVER_STATE_SHOW) { 7774 context.show(); 7775 } 7776 }, context._config.delay.show); 7777 } 7778 7779 _leave(event, context) { 7780 context = this._initializeOnDelegatedTarget(event, context); 7781 7782 if (event) { 7783 context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget); 7784 } 7785 7786 if (context._isWithActiveTrigger()) { 7787 return; 7788 } 7789 7790 clearTimeout(context._timeout); 7791 context._hoverState = HOVER_STATE_OUT; 7792 7793 if (!context._config.delay || !context._config.delay.hide) { 7794 context.hide(); 7795 return; 7796 } 7797 7798 context._timeout = setTimeout(() => { 7799 if (context._hoverState === HOVER_STATE_OUT) { 7800 context.hide(); 7801 } 7802 }, context._config.delay.hide); 7803 } 7804 7805 _isWithActiveTrigger() { 7806 for (const trigger in this._activeTrigger) { 7807 if (this._activeTrigger[trigger]) { 7808 return true; 7809 } 7810 } 7811 7812 return false;
7813 } 7814 7815 _getConfig(config) { 7816 const dataAttributes = Manipulator__default.default.getDataAttributes(this._element); 7817 Object.keys(dataAttributes).forEach(dataAttr => { 7818 if (DISALLOWED_ATTRIBUTES.has(dataAttr)) { 7819 delete dataAttributes[dataAttr]; 7820 } 7821 }); 7822 config = { ...this.constructor.Default, 7823 ...dataAttributes, 7824 ...(typeof config === 'object' && config ? config : {}) 7825 }; 7826 config.container = config.container === false ? document.body : getElement(config.container); 7827 7828 if (typeof config.delay === 'number') { 7829 config.delay = { 7830 show: config.delay, 7831 hide: config.delay 7832 }; 7833 } 7834 7835 if (typeof config.title === 'number') { 7836 config.title = config.title.toString(); 7837 } 7838 7839 if (typeof config.content === 'number') { 7840 config.content = config.content.toString(); 7841 } 7842 7843 typeCheckConfig(NAME, config, this.constructor.DefaultType); 7844 7845 if (config.sanitize) { 7846 config.template = sanitizeHtml(config.template, config.allowList, config.sanitizeFn); 7847 } 7848 7849 return config; 7850 } 7851 7852 _getDelegateConfig() { 7853 const config = {}; 7854 7855 for (const key in this._config) { 7856 if (this.constructor.Default[key] !== this._config[key]) { 7857 config[key] = this._config[key]; 7858 } 7859 } // In the future can be replaced with: 7860 // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]]) 7861 // `Object.fromEntries(keysWithDifferentValues)` 7862 7863 7864 return config; 7865 } 7866 7867 _cleanTipClass() { 7868 const tip = this.getTipElement(); 7869 const basicClassPrefixRegex = new RegExp(`(^|\\s)${this._getBasicClassPrefix()}\\S+`, 'g'); 7870 const tabClass = tip.getAttribute('class').match(basicClassPrefixRegex); 7871 7872 if (tabClass !== null && tabClass.length > 0) { 7873 tabClass.map(token => token.trim()).forEach(tClass => tip.classList.remove(tClass)); 7874 } 7875 } 7876 7877 _getBasicClassPrefix() { 7878 return CLASS_PREFIX; 7879 } 7880 7881 _handlePopperPlacementChange(popperData) { 7882 const { 7883 state 7884 } = popperData; 7885 7886 if (!state) { 7887 return; 7888 } 7889 7890 this.tip = state.elements.popper; 7891 7892 this._cleanTipClass(); 7893 7894 this._addAttachmentClass(this._getAttachment(state.placement)); 7895 } 7896 7897 _disposePopper() { 7898 if (this._popper) { 7899 this._popper.destroy(); 7900 7901 this._popper = null; 7902 } 7903 } // Static 7904 7905 7906 static jQueryInterface(config) { 7907 return this.each(function () { 7908 const data = Tooltip.getOrCreateInstance(this, config); 7909 7910 if (typeof config === 'string') { 7911 if (typeof data[config] === 'undefined') { 7912 throw new TypeError(`No method named "${config}"`); 7913 } 7914 7915 data[config](); 7916 } 7917 }); 7918 } 7919 7920 } 7921 /** 7922 * ------------------------------------------------------------------------ 7923 * jQuery 7924 * ------------------------------------------------------------------------ 7925 * add .Tooltip to jQuery only if jQuery is present 7926 */ 7927 7928 7929 defineJQueryPlugin(Tooltip); 7930 7931 return Tooltip; 7932 7933 })); 7934 7935 }(tooltip$1)); 7936 7937 var tooltip = /*@__PURE__*/getDefaultExportFromCjs(tooltip$1.exports); 7938 7939 /*! 7940 * Bootstrap popover.js v5.1.3 (https://getbootstrap.com/) 7941 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 7942 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 7943 */ 7944 7945 (function (module, exports) { 7946 (function (global, factory) { 7947 module.exports = factory(tooltip$1.exports) ; 7948 })(commonjsGlobal, (function (Tooltip) { 7949 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 7950 7951 const Tooltip__default = /*#__PURE__*/_interopDefaultLegacy(Tooltip); 7952 7953 /** 7954 * -------------------------------------------------------------------------- 7955 * Bootstrap (v5.1.3): util/index.js 7956 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 7957 * -------------------------------------------------------------------------- 7958 */ 7959 7960 const getjQuery = () => { 7961 const { 7962 jQuery 7963 } = window; 7964 7965 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 7966 return jQuery; 7967 } 7968 7969 return null; 7970 }; 7971 7972 const DOMContentLoadedCallbacks = []; 7973 7974 const onDOMContentLoaded = callback => { 7975 if (document.readyState === 'loading') { 7976 // add listener on the first call when the document is in loading state 7977 if (!DOMContentLoadedCallbacks.length) { 7978 document.addEventListener('DOMContentLoaded', () => { 7979 DOMContentLoadedCallbacks.forEach(callback => callback()); 7980 }); 7981 } 7982 7983 DOMContentLoadedCallbacks.push(callback); 7984 } else { 7985 callback(); 7986 } 7987 }; 7988 7989 const defineJQueryPlugin = plugin => { 7990 onDOMContentLoaded(() => { 7991 const $ = getjQuery(); 7992 /* istanbul ignore if */ 7993 7994 if ($) { 7995 const name = plugin.NAME; 7996 const JQUERY_NO_CONFLICT = $.fn[name]; 7997 $.fn[name] = plugin.jQueryInterface; 7998 $.fn[name].Constructor = plugin; 7999 8000 $.fn[name].noConflict = () => { 8001 $.fn[name] = JQUERY_NO_CONFLICT; 8002 return plugin.jQueryInterface; 8003 }; 8004 } 8005 }); 8006 }; 8007 8008 /** 8009 * -------------------------------------------------------------------------- 8010 * Bootstrap (v5.1.3): popover.js 8011 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 8012 * -------------------------------------------------------------------------- 8013 */ 8014 /** 8015 * ------------------------------------------------------------------------ 8016 * Constants 8017 * ------------------------------------------------------------------------ 8018 */ 8019 8020 const NAME = 'popover'; 8021 const DATA_KEY = 'bs.popover'; 8022 const EVENT_KEY = `.${DATA_KEY}`;
8023 const CLASS_PREFIX = 'bs-popover'; 8024 const Default = { ...Tooltip__default.default.Default, 8025 placement: 'right', 8026 offset: [0, 8], 8027 trigger: 'click', 8028 content: '', 8029 template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>' 8030 }; 8031 const DefaultType = { ...Tooltip__default.default.DefaultType, 8032 content: '(string|element|function)' 8033 }; 8034 const Event = { 8035 HIDE: `hide${EVENT_KEY}`, 8036 HIDDEN: `hidden${EVENT_KEY}`, 8037 SHOW: `show${EVENT_KEY}`, 8038 SHOWN: `shown${EVENT_KEY}`, 8039 INSERTED: `inserted${EVENT_KEY}`, 8040 CLICK: `click${EVENT_KEY}`, 8041 FOCUSIN: `focusin${EVENT_KEY}`, 8042 FOCUSOUT: `focusout${EVENT_KEY}`, 8043 MOUSEENTER: `mouseenter${EVENT_KEY}`, 8044 MOUSELEAVE: `mouseleave${EVENT_KEY}` 8045 }; 8046 const SELECTOR_TITLE = '.popover-header'; 8047 const SELECTOR_CONTENT = '.popover-body'; 8048 /** 8049 * ------------------------------------------------------------------------ 8050 * Class Definition 8051 * ------------------------------------------------------------------------ 8052 */ 8053 8054 class Popover extends Tooltip__default.default { 8055 // Getters 8056 static get Default() { 8057 return Default; 8058 } 8059 8060 static get NAME() { 8061 return NAME; 8062 } 8063 8064 static get Event() { 8065 return Event; 8066 } 8067 8068 static get DefaultType() { 8069 return DefaultType; 8070 } // Overrides 8071 8072 8073 isWithContent() { 8074 return this.getTitle() || this._getContent(); 8075 } 8076 8077 setContent(tip) { 8078 this._sanitizeAndSetContent(tip, this.getTitle(), SELECTOR_TITLE); 8079 8080 this._sanitizeAndSetContent(tip, this._getContent(), SELECTOR_CONTENT); 8081 } // Private 8082 8083 8084 _getContent() { 8085 return this._resolvePossibleFunction(this._config.content); 8086 } 8087 8088 _getBasicClassPrefix() { 8089 return CLASS_PREFIX; 8090 } // Static 8091 8092 8093 static jQueryInterface(config) { 8094 return this.each(function () { 8095 const data = Popover.getOrCreateInstance(this, config); 8096 8097 if (typeof config === 'string') { 8098 if (typeof data[config] === 'undefined') { 8099 throw new TypeError(`No method named "${config}"`); 8100 } 8101 8102 data[config](); 8103 } 8104 }); 8105 } 8106 8107 } 8108 /** 8109 * ------------------------------------------------------------------------ 8110 * jQuery 8111 * ------------------------------------------------------------------------ 8112 * add .Popover to jQuery only if jQuery is present 8113 */ 8114 8115 8116 defineJQueryPlugin(Popover); 8117 8118 return Popover; 8119 8120 })); 8121 8122 }(popover$1)); 8123 8124 var popover = popover$1.exports; 8125 8126 var scrollspy$1 = {exports: {}}; 8127 8128 /*! 8129 * Bootstrap scrollspy.js v5.1.3 (https://getbootstrap.com/) 8130 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 8131 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 8132 */ 8133 8134 (function (module, exports) { 8135 (function (global, factory) { 8136 module.exports = factory(eventHandler.exports, manipulator.exports, selectorEngine.exports, baseComponent.exports) ; 8137 })(commonjsGlobal, (function (EventHandler, Manipulator, SelectorEngine, BaseComponent) { 8138 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 8139 8140 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 8141 const Manipulator__default = /*#__PURE__*/_interopDefaultLegacy(Manipulator); 8142 const SelectorEngine__default = /*#__PURE__*/_interopDefaultLegacy(SelectorEngine); 8143 const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); 8144 8145 /** 8146 * -------------------------------------------------------------------------- 8147 * Bootstrap (v5.1.3): util/index.js 8148 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 8149 * -------------------------------------------------------------------------- 8150 */ 8151 8152 const toType = obj => { 8153 if (obj === null || obj === undefined) { 8154 return `${obj}`; 8155 } 8156 8157 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 8158 }; 8159 8160 const getSelector = element => { 8161 let selector = element.getAttribute('data-bs-target'); 8162 8163 if (!selector || selector === '#') { 8164 let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes, 8165 // so everything starting with `#` or `.`. If a "real" URL is used as the selector, 8166 // `document.querySelector` will rightfully complain it is invali
8166d. 8167 // See https://github.com/twbs/bootstrap/issues/32273 8168 8169 if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) { 8170 return null; 8171 } // Just in case some CMS puts out a full URL with the anchor appended 8172 8173 8174 if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) { 8175 hrefAttr = `#${hrefAttr.split('#')[1]}`; 8176 } 8177 8178 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null; 8179 } 8180 8181 return selector; 8182 }; 8183 8184 const getSelectorFromElement = element => { 8185 const selector = getSelector(element); 8186 8187 if (selector) { 8188 return document.querySelector(selector) ? selector : null; 8189 } 8190 8191 return null; 8192 }; 8193 8194 const isElement = obj => { 8195 if (!obj || typeof obj !== 'object') { 8196 return false; 8197 } 8198 8199 if (typeof obj.jquery !== 'undefined') { 8200 obj = obj[0]; 8201 } 8202 8203 return typeof obj.nodeType !== 'undefined'; 8204 }; 8205 8206 const getElement = obj => { 8207 if (isElement(obj)) { 8208 // it's a jQuery object or a node element 8209 return obj.jquery ? obj[0] : obj; 8210 } 8211 8212 if (typeof obj === 'string' && obj.length > 0) { 8213 return document.querySelector(obj); 8214 } 8215 8216 return null; 8217 }; 8218 8219 const typeCheckConfig = (componentName, config, configTypes) => { 8220 Object.keys(configTypes).forEach(property => { 8221 const expectedTypes = configTypes[property]; 8222 const value = config[property]; 8223 const valueType = value && isElement(value) ? 'element' : toType(value); 8224 8225 if (!new RegExp(expectedTypes).test(valueType)) { 8226 throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); 8227 } 8228 }); 8229 }; 8230 8231 const getjQuery = () => { 8232 const { 8233 jQuery 8234 } = window; 8235 8236 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 8237 return jQuery; 8238 } 8239 8240 return null; 8241 }; 8242 8243 const DOMContentLoadedCallbacks = []; 8244 8245 const onDOMContentLoaded = callback => { 8246 if (document.readyState === 'loading') { 8247 // add listener on the first call when the document is in loading state 8248 if (!DOMContentLoadedCallbacks.length) { 8249 document.addEventListener('DOMContentLoaded', () => { 8250 DOMContentLoadedCallbacks.forEach(callback => callback()); 8251 }); 8252 } 8253 8254 DOMContentLoadedCallbacks.push(callback); 8255 } else { 8256 callback(); 8257 } 8258 }; 8259 8260 const defineJQueryPlugin = plugin => { 8261 onDOMContentLoaded(() => { 8262 const $ = getjQuery(); 8263 /* istanbul ignore if */ 8264 8265 if ($) { 8266 const name = plugin.NAME; 8267 const JQUERY_NO_CONFLICT = $.fn[name]; 8268 $.fn[name] = plugin.jQueryInterface; 8269 $.fn[name].Constructor = plugin; 8270 8271 $.fn[name].noConflict = () => { 8272 $.fn[name] = JQUERY_NO_CONFLICT; 8273 return plugin.jQueryInterface; 8274 }; 8275 } 8276 }); 8277 }; 8278 8279 /** 8280 * -------------------------------------------------------------------------- 8281 * Bootstrap (v5.1.3): scrollspy.js 8282 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 8283 * -------------------------------------------------------------------------- 8284 */ 8285 /** 8286 * ------------------------------------------------------------------------ 8287 * Constants 8288 * ------------------------------------------------------------------------ 8289 */ 8290 8291 const NAME = 'scrollspy'; 8292 const DATA_KEY = 'bs.scrollspy'; 8293 const EVENT_KEY = `.${DATA_KEY}`; 8294 const DATA_API_KEY = '.data-api'; 8295 const Default = { 8296 offset: 10, 8297 method: 'auto', 8298 target: '' 8299 }; 8300 const DefaultType = { 8301 offset: 'number', 8302 method: 'string', 8303 target: '(string|element)' 8304 }; 8305 const EVENT_ACTIVATE = `activate${EVENT_KEY}`; 8306 const EVENT_SCROLL = `scroll${EVENT_KEY}`; 8307 const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`; 8308 const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item'; 8309 const CLASS_NAME_ACTIVE = 'active'; 8310 const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]'; 8311 const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'; 8312 const SELECTOR_NAV_LINKS = '.nav-link'; 8313 const SELECTOR_NAV_ITEMS = '.nav-item'; 8314 const SELECTOR_LIST_ITEMS = '.list-group-item'; 8315 const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}
8315, .${CLASS_NAME_DROPDOWN_ITEM}`; 8316 const SELECTOR_DROPDOWN = '.dropdown'; 8317 const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'; 8318 const METHOD_OFFSET = 'offset'; 8319 const METHOD_POSITION = 'position'; 8320 /** 8321 * ------------------------------------------------------------------------ 8322 * Class Definition 8323 * ------------------------------------------------------------------------ 8324 */ 8325 8326 class ScrollSpy extends BaseComponent__default.default { 8327 constructor(element, config) { 8328 super(element); 8329 this._scrollElement = this._element.tagName === 'BODY' ? window : this._element; 8330 this._config = this._getConfig(config); 8331 this._offsets = []; 8332 this._targets = []; 8333 this._activeTarget = null; 8334 this._scrollHeight = 0; 8335 EventHandler__default.default.on(this._scrollElement, EVENT_SCROLL, () => this._process()); 8336 this.refresh(); 8337 8338 this._process(); 8339 } // Getters 8340 8341 8342 static get Default() { 8343 return Default; 8344 } 8345 8346 static get NAME() { 8347 return NAME; 8348 } // Public 8349 8350 8351 refresh() { 8352 const autoMethod = this._scrollElement === this._scrollElement.window ? METHOD_OFFSET : METHOD_POSITION; 8353 const offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method; 8354 const offsetBase = offsetMethod === METHOD_POSITION ? this._getScrollTop() : 0; 8355 this._offsets = []; 8356 this._targets = []; 8357 this._scrollHeight = this._getScrollHeight(); 8358 const targets = SelectorEngine__default.default.find(SELECTOR_LINK_ITEMS, this._config.target); 8359 targets.map(element => { 8360 const targetSelector = getSelectorFromElement(element); 8361 const target = targetSelector ? SelectorEngine__default.default.findOne(targetSelector) : null; 8362 8363 if (target) { 8364 const targetBCR = target.getBoundingClientRect(); 8365 8366 if (targetBCR.width || targetBCR.height) { 8367 return [Manipulator__default.default[offsetMethod](target).top + offsetBase, targetSelector]; 8368 } 8369 } 8370 8371 return null; 8372 }).filter(item => item).sort((a, b) => a[0] - b[0]).forEach(item => { 8373 this._offsets.push(item[0]); 8374 8375 this._targets.push(item[1]); 8376 }); 8377 } 8378 8379 dispose() { 8380 EventHandler__default.default.off(this._scrollElement, EVENT_KEY); 8381 super.dispose(); 8382 } // Private 8383 8384 8385 _getConfig(config) { 8386 config = { ...Default, 8387 ...Manipulator__default.default.getDataAttributes(this._element), 8388 ...(typeof config === 'object' && config ? config : {}) 8389 }; 8390 config.target = getElement(config.target) || document.documentElement; 8391 typeCheckConfig(NAME, config, DefaultType); 8392 return config; 8393 } 8394 8395 _getScrollTop() { 8396 return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop; 8397 } 8398 8399 _getScrollHeight() { 8400 return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight); 8401 } 8402 8403 _getOffsetHeight() { 8404 return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height; 8405 } 8406 8407 _process() { 8408 const scrollTop = this._getScrollTop() + this._config.offset; 8409 8410 const scrollHeight = this._getScrollHeight(); 8411 8412 const maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight(); 8413 8414 if (this._scrollHeight !== scrollHeight) { 8415 this.refresh(); 8416 } 8417 8418 if (scrollTop >= maxScroll) { 8419 const target = this._targets[this._targets.length - 1]; 8420 8421 if (this._activeTarget !== target) { 8422 this._activate(target); 8423 } 8424 8425 return; 8426 } 8427 8428 if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) { 8429 this._activeTarget = null; 8430 8431 this._clear(); 8432 8433 return; 8434 } 8435 8436 for (let i = this._offsets.length; i--;) { 8437 const isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]); 8438 8439 if (isActiveTarget) { 8440 this._activate(this._targets[i]); 8441 } 8442 } 8443 } 8444 8445 _activate(target) { 8446 this._activeTarget = target; 8447 8448 this._clear(); 8449 8450 const queries = SELECTOR_LINK_ITEMS.split(',').map(selector => `${selector}[data-bs-target="${target}"],${selector}[href="${target}"]`); 8451 const link = SelectorEngine__default.default.findOne(queries.join(','), this._config.target); 8452 link.classList.add(CLASS_NAME_ACTIVE); 8453
8454 if (link.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) { 8455 SelectorEngine__default.default.findOne(SELECTOR_DROPDOWN_TOGGLE, link.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE); 8456 } else { 8457 SelectorEngine__default.default.parents(link, SELECTOR_NAV_LIST_GROUP).forEach(listGroup => { 8458 // Set triggered links parents as active 8459 // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor 8460 SelectorEngine__default.default.prev(listGroup, `${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`).forEach(item => item.classList.add(CLASS_NAME_ACTIVE)); // Handle special case when .nav-link is inside .nav-item 8461 8462 SelectorEngine__default.default.prev(listGroup, SELECTOR_NAV_ITEMS).forEach(navItem => { 8463 SelectorEngine__default.default.children(navItem, SELECTOR_NAV_LINKS).forEach(item => item.classList.add(CLASS_NAME_ACTIVE)); 8464 }); 8465 }); 8466 } 8467 8468 EventHandler__default.default.trigger(this._scrollElement, EVENT_ACTIVATE, { 8469 relatedTarget: target 8470 }); 8471 } 8472 8473 _clear() { 8474 SelectorEngine__default.default.find(SELECTOR_LINK_ITEMS, this._config.target).filter(node => node.classList.contains(CLASS_NAME_ACTIVE)).forEach(node => node.classList.remove(CLASS_NAME_ACTIVE)); 8475 } // Static 8476 8477 8478 static jQueryInterface(config) { 8479 return this.each(function () { 8480 const data = ScrollSpy.getOrCreateInstance(this, config); 8481 8482 if (typeof config !== 'string') { 8483 return; 8484 } 8485 8486 if (typeof data[config] === 'undefined') { 8487 throw new TypeError(`No method named "${config}"`); 8488 } 8489 8490 data[config](); 8491 }); 8492 } 8493 8494 } 8495 /** 8496 * ------------------------------------------------------------------------ 8497 * Data Api implementation 8498 * ------------------------------------------------------------------------ 8499 */ 8500 8501 8502 EventHandler__default.default.on(window, EVENT_LOAD_DATA_API, () => { 8503 SelectorEngine__default.default.find(SELECTOR_DATA_SPY).forEach(spy => new ScrollSpy(spy)); 8504 }); 8505 /** 8506 * ------------------------------------------------------------------------ 8507 * jQuery 8508 * ------------------------------------------------------------------------ 8509 * add .ScrollSpy to jQuery only if jQuery is present 8510 */ 8511 8512 defineJQueryPlugin(ScrollSpy); 8513 8514 return ScrollSpy; 8515 8516 })); 8517 8518 }(scrollspy$1)); 8519 8520 var scrollspy = scrollspy$1.exports; 8521 8522 var tab$1 = {exports: {}}; 8523 8524 /*! 8525 * Bootstrap tab.js v5.1.3 (https://getbootstrap.com/) 8526 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 8527 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 8528 */ 8529 8530 (function (module, exports) { 8531 (function (global, factory) { 8532 module.exports = factory(eventHandler.exports, selectorEngine.exports, baseComponent.exports) ; 8533 })(commonjsGlobal, (function (EventHandler, SelectorEngine, BaseComponent) { 8534 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 8535 8536 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 8537 const SelectorEngine__default = /*#__PURE__*/_interopDefaultLegacy(SelectorEngine); 8538 const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); 8539 8540 /** 8541 * -------------------------------------------------------------------------- 8542 * Bootstrap (v5.1.3): util/index.js 8543 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 8544 * -------------------------------------------------------------------------- 8545 */ 8546 8547 const getSelector = element => { 8548 let selector = element.getAttribute('data-bs-target'); 8549 8550 if (!selector || selector === '#') { 8551 let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes, 8552 // so everything starting with `#` or `.`. If a "real" URL is used as the selector, 8553 // `document.querySelector` will rightfully complain it is invali
8553d. 8554 // See https://github.com/twbs/bootstrap/issues/32273 8555 8556 if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) { 8557 return null; 8558 } // Just in case some CMS puts out a full URL with the anchor appended 8559 8560 8561 if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) { 8562 hrefAttr = `#${hrefAttr.split('#')[1]}`; 8563 } 8564 8565 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null; 8566 } 8567 8568 return selector; 8569 }; 8570 8571 const getElementFromSelector = element => { 8572 const selector = getSelector(element); 8573 return selector ? document.querySelector(selector) : null; 8574 }; 8575 8576 const isDisabled = element => { 8577 if (!element || element.nodeType !== Node.ELEMENT_NODE) { 8578 return true; 8579 } 8580 8581 if (element.classList.contains('disabled')) { 8582 return true; 8583 } 8584 8585 if (typeof element.disabled !== 'undefined') { 8586 return element.disabled; 8587 } 8588 8589 return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'; 8590 }; 8591 /** 8592 * Trick to restart an element's animation 8593 * 8594 * @param {HTMLElement} element 8595 * @return void 8596 * 8597 * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation 8598 */ 8599 8600 8601 const reflow = element => { 8602 // eslint-disable-next-line no-unused-expressions 8603 element.offsetHeight; 8604 }; 8605 8606 const getjQuery = () => { 8607 const { 8608 jQuery 8609 } = window; 8610 8611 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 8612 return jQuery; 8613 } 8614 8615 return null; 8616 }; 8617 8618 const DOMContentLoadedCallbacks = []; 8619 8620 const onDOMContentLoaded = callback => { 8621 if (document.readyState === 'loading') { 8622 // add listener on the first call when the document is in loading state 8623 if (!DOMContentLoadedCallbacks.length) { 8624 document.addEventListener('DOMContentLoaded', () => { 8625 DOMContentLoadedCallbacks.forEach(callback => callback()); 8626 }); 8627 } 8628 8629 DOMContentLoadedCallbacks.push(callback); 8630 } else { 8631 callback(); 8632 } 8633 }; 8634 8635 const defineJQueryPlugin = plugin => { 8636 onDOMContentLoaded(() => { 8637 const $ = getjQuery(); 8638 /* istanbul ignore if */ 8639 8640 if ($) { 8641 const name = plugin.NAME; 8642 const JQUERY_NO_CONFLICT = $.fn[name]; 8643 $.fn[name] = plugin.jQueryInterface; 8644 $.fn[name].Constructor = plugin; 8645 8646 $.fn[name].noConflict = () => { 8647 $.fn[name] = JQUERY_NO_CONFLICT; 8648 return plugin.jQueryInterface; 8649 }; 8650 } 8651 }); 8652 }; 8653 8654 /** 8655 * -------------------------------------------------------------------------- 8656 * Bootstrap (v5.1.3): tab.js 8657 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 8658 * -------------------------------------------------------------------------- 8659 */ 8660 /** 8661 * ------------------------------------------------------------------------ 8662 * Constants 8663 * ------------------------------------------------------------------------ 8664 */ 8665 8666 const NAME = 'tab'; 8667 const DATA_KEY = 'bs.tab'; 8668 const EVENT_KEY = `.${DATA_KEY}`; 8669 const DATA_API_KEY = '.data-api'; 8670 const EVENT_HIDE = `hide${EVENT_KEY}`; 8671 const EVENT_HIDDEN = `hidden${EVENT_KEY}`; 8672 const EVENT_SHOW = `show${EVENT_KEY}`; 8673 const EVENT_SHOWN = `shown${EVENT_KEY}`; 8674 const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`; 8675 const CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu'; 8676 const CLASS_NAME_ACTIVE = 'active'; 8677 const CLASS_NAME_FADE = 'fade'; 8678 const CLASS_NAME_SHOW = 'show'; 8679 const SELECTOR_DROPDOWN = '.dropdown'; 8680 const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'; 8681 const SELECTOR_ACTIVE = '.active'; 8682 const SELECTOR_ACTIVE_UL = ':scope > li > .active'; 8683 const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]'; 8684 const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'; 8685 const SELECTOR_DROPDOWN_ACTIVE_CHILD = ':scope > .dropdown-menu .active'; 8686 /** 8687 * ------------------------------------------------------------------------ 8688 * Class Definition 8689 * ------------------------------------------------------------------------ 8690 */ 8691 8692 class Tab extends BaseComponent__default.default { 8693 // Getters 8694 static get NAME() { 8695 return NAME; 8696 } // Public 8697 8698 8699 show() { 8700 if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && this._element.classList.contains(CLASS_NAME_ACTIVE)) { 8701 return; 8702 } 8703 8704 let previous; 8705 const target = getElementFromSelector(this._element); 8706 8707 const listElement = this._element.closest(SELECTOR_NAV_LIST_GROUP); 8708 8709 if (listElement) { 8710 const itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? SELECTOR_ACTIVE_UL : SELECTOR_ACTIVE; 8711 previous = SelectorEngine__default.default.find(itemSelector, listElement); 8712 previous = previous[previous.length - 1]; 8713 } 8714 8715 const hideEvent = previous ? EventHandler__default.default.trigger(previous, EVENT_HIDE, { 8716 relatedTarget: this._element 8717 }) : null; 8718 const showEvent = EventHandler__default.default.trigger(this._element, EVENT_SHOW, { 8719 relatedTarget: previous 8720 }); 8721 8722 if (showEvent.defaultPrevented || hideEvent !== null && hideEvent.defaultPrevented) { 8723 return; 8724 } 8725 8726 this._activate(this._element, listElement); 8727 8728 const complete = () => { 8729 EventHandler__default.default.trigger(previous, EVENT_HIDDEN, { 8730 relatedTarget: this._element 8731 }); 8732 EventHandler__default.default.trigger(this._element, EVENT_SHOWN, { 8733 relatedTarget: previous 8734 }); 8735 }; 8736 8737 if (target) { 8738 this._activate(target, target.parentNode, complete); 8739 } else { 8740 complete(); 8741 } 8742 } // Private 8743 8744 8745 _activate(element, container, callback) { 8746 const activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? SelectorEngine__default.default.find(SELECTOR_ACTIVE_UL, container) : SelectorEngine__default.default.children(container, SELECTOR_ACTIVE); 8747 const active = activeElements[0]; 8748 const isTransitioning = callback && active && active.classList.contains(CLASS_NAME_FADE); 8749 8750 const complete = () => this._transitionComplete(element, active, callback); 8751 8752 if (active && isTransitioning) { 8753 active.classList.remove(CLASS_NAME_SHOW); 8754 8755 this._queueCallback(complete, element, true); 8756 } else { 8757 complete(); 8758 } 8759 } 8760 8761 _transitionComplete(element, active, callback) { 8762 if (active) { 8763 active.classList.remove(CLASS_NAME_ACTIVE);
8764 const dropdownChild = SelectorEngine__default.default.findOne(SELECTOR_DROPDOWN_ACTIVE_CHILD, active.parentNode); 8765 8766 if (dropdownChild) { 8767 dropdownChild.classList.remove(CLASS_NAME_ACTIVE); 8768 } 8769 8770 if (active.getAttribute('role') === 'tab') { 8771 active.setAttribute('aria-selected', false); 8772 } 8773 } 8774 8775 element.classList.add(CLASS_NAME_ACTIVE); 8776 8777 if (element.getAttribute('role') === 'tab') { 8778 element.setAttribute('aria-selected', true); 8779 } 8780 8781 reflow(element); 8782 8783 if (element.classList.contains(CLASS_NAME_FADE)) { 8784 element.classList.add(CLASS_NAME_SHOW); 8785 } 8786 8787 let parent = element.parentNode; 8788 8789 if (parent && parent.nodeName === 'LI') { 8790 parent = parent.parentNode; 8791 } 8792 8793 if (parent && parent.classList.contains(CLASS_NAME_DROPDOWN_MENU)) { 8794 const dropdownElement = element.closest(SELECTOR_DROPDOWN); 8795 8796 if (dropdownElement) { 8797 SelectorEngine__default.default.find(SELECTOR_DROPDOWN_TOGGLE, dropdownElement).forEach(dropdown => dropdown.classList.add(CLASS_NAME_ACTIVE)); 8798 } 8799 8800 element.setAttribute('aria-expanded', true); 8801 } 8802 8803 if (callback) { 8804 callback(); 8805 } 8806 } // Static 8807 8808 8809 static jQueryInterface(config) { 8810 return this.each(function () { 8811 const data = Tab.getOrCreateInstance(this); 8812 8813 if (typeof config === 'string') { 8814 if (typeof data[config] === 'undefined') { 8815 throw new TypeError(`No method named "${config}"`); 8816 } 8817 8818 data[config](); 8819 } 8820 }); 8821 } 8822 8823 } 8824 /** 8825 * ------------------------------------------------------------------------ 8826 * Data Api implementation 8827 * ------------------------------------------------------------------------ 8828 */ 8829 8830 8831 EventHandler__default.default.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { 8832 if (['A', 'AREA'].includes(this.tagName)) { 8833 event.preventDefault(); 8834 } 8835 8836 if (isDisabled(this)) { 8837 return; 8838 } 8839 8840 const data = Tab.getOrCreateInstance(this); 8841 data.show(); 8842 }); 8843 /** 8844 * ------------------------------------------------------------------------ 8845 * jQuery 8846 * ------------------------------------------------------------------------ 8847 * add .Tab to jQuery only if jQuery is present 8848 */ 8849 8850 defineJQueryPlugin(Tab); 8851 8852 return Tab; 8853 8854 })); 8855 8856 }(tab$1)); 8857 8858 var tab = tab$1.exports; 8859 8860 var toast$1 = {exports: {}}; 8861 8862 /*! 8863 * Bootstrap toast.js v5.1.3 (https://getbootstrap.com/) 8864 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 8865 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 8866 */ 8867 8868 (function (module, exports) { 8869 (function (global, factory) { 8870 module.exports = factory(eventHandler.exports, manipulator.exports, baseComponent.exports) ; 8871 })(commonjsGlobal, (function (EventHandler, Manipulator, BaseComponent) { 8872 const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; 8873 8874 const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler); 8875 const Manipulator__default = /*#__PURE__*/_interopDefaultLegacy(Manipulator); 8876 const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent); 8877 8878 /** 8879 * -------------------------------------------------------------------------- 8880 * Bootstrap (v5.1.3): util/index.js 8881 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 8882 * -------------------------------------------------------------------------- 8883 */ 8884 8885 const toType = obj => { 8886 if (obj === null || obj === undefined) { 8887 return `${obj}`; 8888 } 8889 8890 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 8891 }; 8892 8893 const getSelector = element => { 8894 let selector = element.getAttribute('data-bs-target'); 8895 8896 if (!selector || selector === '#') { 8897 let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes, 8898 // so everything starting with `#` or `.`. If a "real" URL is used as the selector, 8899 // `document.querySelector` will rightfully complain it is invali
8899d. 8900 // See https://github.com/twbs/bootstrap/issues/32273 8901 8902 if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) { 8903 return null; 8904 } // Just in case some CMS puts out a full URL with the anchor appended 8905 8906 8907 if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) { 8908 hrefAttr = `#${hrefAttr.split('#')[1]}`; 8909 } 8910 8911 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null; 8912 } 8913 8914 return selector; 8915 }; 8916 8917 const getElementFromSelector = element => { 8918 const selector = getSelector(element); 8919 return selector ? document.querySelector(selector) : null; 8920 }; 8921 8922 const isElement = obj => { 8923 if (!obj || typeof obj !== 'object') { 8924 return false; 8925 } 8926 8927 if (typeof obj.jquery !== 'undefined') { 8928 obj = obj[0]; 8929 } 8930 8931 return typeof obj.nodeType !== 'undefined'; 8932 }; 8933 8934 const typeCheckConfig = (componentName, config, configTypes) => { 8935 Object.keys(configTypes).forEach(property => { 8936 const expectedTypes = configTypes[property]; 8937 const value = config[property]; 8938 const valueType = value && isElement(value) ? 'element' : toType(value); 8939 8940 if (!new RegExp(expectedTypes).test(valueType)) { 8941 throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); 8942 } 8943 }); 8944 }; 8945 8946 const isDisabled = element => { 8947 if (!element || element.nodeType !== Node.ELEMENT_NODE) { 8948 return true; 8949 } 8950 8951 if (element.classList.contains('disabled')) { 8952 return true; 8953 } 8954 8955 if (typeof element.disabled !== 'undefined') { 8956 return element.disabled; 8957 } 8958 8959 return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'; 8960 }; 8961 /** 8962 * Trick to restart an element's animation 8963 * 8964 * @param {HTMLElement} element 8965 * @return void 8966 * 8967 * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation 8968 */ 8969 8970 8971 const reflow = element => { 8972 // eslint-disable-next-line no-unused-expressions 8973 element.offsetHeight; 8974 }; 8975 8976 const getjQuery = () => { 8977 const { 8978 jQuery 8979 } = window; 8980 8981 if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 8982 return jQuery; 8983 } 8984 8985 return null; 8986 }; 8987 8988 const DOMContentLoadedCallbacks = []; 8989 8990 const onDOMContentLoaded = callback => { 8991 if (document.readyState === 'loading') { 8992 // add listener on the first call when the document is in loading state 8993 if (!DOMContentLoadedCallbacks.length) { 8994 document.addEventListener('DOMContentLoaded', () => { 8995 DOMContentLoadedCallbacks.forEach(callback => callback()); 8996 }); 8997 } 8998 8999 DOMContentLoadedCallbacks.push(callback); 9000 } else { 9001 callback(); 9002 } 9003 }; 9004 9005 const defineJQueryPlugin = plugin => { 9006 onDOMContentLoaded(() => { 9007 const $ = getjQuery(); 9008 /* istanbul ignore if */ 9009 9010 if ($) { 9011 const name = plugin.NAME; 9012 const JQUERY_NO_CONFLICT = $.fn[name]; 9013 $.fn[name] = plugin.jQueryInterface; 9014 $.fn[name].Constructor = plugin; 9015 9016 $.fn[name].noConflict = () => { 9017 $.fn[name] = JQUERY_NO_CONFLICT; 9018 return plugin.jQueryInterface; 9019 }; 9020 } 9021 }); 9022 }; 9023 9024 /** 9025 * -------------------------------------------------------------------------- 9026 * Bootstrap (v5.1.3): util/component-functions.js 9027 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 9028 * -------------------------------------------------------------------------- 9029 */ 9030 9031 const enableDismissTrigger = (component, method = 'hide') => { 9032 const clickEvent = `click.dismiss${component.EVENT_KEY}`; 9033 const name = component.NAME; 9034 EventHandler__default.default.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) { 9035 if (['A', 'AREA'].includes(this.tagName)) { 9036 event.preventDefault(); 9037 } 9038 9039 if (isDisabled(this)) { 9040 return; 9041 } 9042 9043 const target = getElementFromSelector(this) || this.closest(`.${name}`); 9044 const instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method 9045 9046 instance[method](); 9047 }); 9048 }; 9049 9050 /** 9051 * -------------------------------------------------------------------------- 9052 * Bootstrap (v5.1.3): toast.js 9053 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 9054 * -------------------------------------------------------------------------- 9055 */ 9056 /** 9057 * ------------------------------------------------------------------------ 9058 * Constants 9059 * ------------------------------------------------------------------------ 9060 */ 9061 9062 const NAME = 'toast'; 9063 const DATA_KEY = 'bs.toast'; 9064 const EVENT_KEY = `.${DATA_KEY}`; 9065 const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`;
9066 const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`; 9067 const EVENT_FOCUSIN = `focusin${EVENT_KEY}`; 9068 const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`; 9069 const EVENT_HIDE = `hide${EVENT_KEY}`; 9070 const EVENT_HIDDEN = `hidden${EVENT_KEY}`; 9071 const EVENT_SHOW = `show${EVENT_KEY}`; 9072 const EVENT_SHOWN = `shown${EVENT_KEY}`; 9073 const CLASS_NAME_FADE = 'fade'; 9074 const CLASS_NAME_HIDE = 'hide'; // @deprecated - kept here only for backwards compatibility 9075 9076 const CLASS_NAME_SHOW = 'show'; 9077 const CLASS_NAME_SHOWING = 'showing'; 9078 const DefaultType = { 9079 animation: 'boolean', 9080 autohide: 'boolean', 9081 delay: 'number' 9082 }; 9083 const Default = { 9084 animation: true, 9085 autohide: true, 9086 delay: 5000 9087 }; 9088 /** 9089 * ------------------------------------------------------------------------ 9090 * Class Definition 9091 * ------------------------------------------------------------------------ 9092 */ 9093 9094 class Toast extends BaseComponent__default.default { 9095 constructor(element, config) { 9096 super(element); 9097 this._config = this._getConfig(config); 9098 this._timeout = null; 9099 this._hasMouseInteraction = false; 9100 this._hasKeyboardInteraction = false; 9101 9102 this._setListeners(); 9103 } // Getters 9104 9105 9106 static get DefaultType() { 9107 return DefaultType; 9108 } 9109 9110 static get Default() { 9111 return Default; 9112 } 9113 9114 static get NAME() { 9115 return NAME; 9116 } // Public 9117 9118 9119 show() { 9120 const showEvent = EventHandler__default.default.trigger(this._element, EVENT_SHOW); 9121 9122 if (showEvent.defaultPrevented) { 9123 return; 9124 } 9125 9126 this._clearTimeout(); 9127 9128 if (this._config.animation) { 9129 this._element.classList.add(CLASS_NAME_FADE); 9130 } 9131 9132 const complete = () => { 9133 this._element.classList.remove(CLASS_NAME_SHOWING); 9134 9135 EventHandler__default.default.trigger(this._element, EVENT_SHOWN); 9136 9137 this._maybeScheduleHide(); 9138 }; 9139 9140 this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated 9141 9142 9143 reflow(this._element); 9144 9145 this._element.classList.add(CLASS_NAME_SHOW); 9146 9147 this._element.classList.add(CLASS_NAME_SHOWING); 9148 9149 this._queueCallback(complete, this._element, this._config.animation); 9150 } 9151 9152 hide() { 9153 if (!this._element.classList.contains(CLASS_NAME_SHOW)) { 9154 return; 9155 } 9156 9157 const hideEvent = EventHandler__default.default.trigger(this._element, EVENT_HIDE); 9158 9159 if (hideEvent.defaultPrevented) { 9160 return; 9161 } 9162 9163 const complete = () => { 9164 this._element.classList.add(CLASS_NAME_HIDE); // @deprecated 9165 9166 9167 this._element.classList.remove(CLASS_NAME_SHOWING); 9168 9169 this._element.classList.remove(CLASS_NAME_SHOW); 9170 9171 EventHandler__default.default.trigger(this._element, EVENT_HIDDEN); 9172 }; 9173 9174 this._element.classList.add(CLASS_NAME_SHOWING); 9175 9176 this._queueCallback(complete, this._element, this._config.animation); 9177 } 9178 9179 dispose() { 9180 this._clearTimeout(); 9181 9182 if (this._element.classList.contains(CLASS_NAME_SHOW)) { 9183 this._element.classList.remove(CLASS_NAME_SHOW); 9184 } 9185 9186 super.dispose(); 9187 } // Private 9188 9189 9190 _getConfig(config) { 9191 config = { ...Default, 9192 ...Manipulator__default.default.getDataAttributes(this._element), 9193 ...(typeof config === 'object' && config ? config : {}) 9194 }; 9195 typeCheckConfig(NAME, config, this.constructor.DefaultType); 9196 return config; 9197 } 9198 9199 _maybeScheduleHide() { 9200 if (!this._config.autohide) { 9201 return; 9202 } 9203 9204 if (this._hasMouseInteraction || this._hasKeyboardInteraction) { 9205 return; 9206 } 9207 9208 this._timeout = setTimeout(() => { 9209 this.hide(); 9210 }, this._config.delay); 9211 } 9212 9213 _onInteraction(event, isInteracting) { 9214 switch (event.type) { 9215 case 'mouseover': 9216 case 'mouseout': 9217 this._hasMouseInteraction = isInteracting; 9218 break; 9219 9220 case 'focusin': 9221 case 'focusout': 9222 this._hasKeyboardInteraction = isInteracting; 9223 break; 9224 } 9225 9226 if (isInteracting) { 9227 this._clearTimeout(); 9228 9229 return; 9230 } 9231 9232 const nextElement = event.relatedTarget; 9233 9234 if (this._element === nextElement || this._element.contains(nextElement)) { 9235 return; 9236 } 9237 9238 this._maybeScheduleHide(); 9239 } 9240 9241 _setListeners() { 9242 EventHandler__default.default.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true)); 9243 EventHandler__default.default.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false)); 9244 EventHandler__default.default.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true)); 9245 EventHandler__default.default.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false)); 9246 } 9247 9248 _clearTimeout() { 9249 clearTimeout(this._timeout); 9250 this._timeout = null; 9251 } // Static 9252 9253 9254 static jQueryInterface(config) { 9255 return this.each(function () { 9256 const data = Toast.getOrCreateInstance(this, config); 9257 9258 if (typeof config === 'string') { 9259 if (typeof data[config] === 'undefined') {
9260 throw new TypeError(`No method named "${config}"`); 9261 } 9262 9263 data[config](this); 9264 } 9265 }); 9266 } 9267 9268 } 9269 9270 enableDismissTrigger(Toast); 9271 /** 9272 * ------------------------------------------------------------------------ 9273 * jQuery 9274 * ------------------------------------------------------------------------ 9275 * add .Toast to jQuery only if jQuery is present 9276 */ 9277 9278 defineJQueryPlugin(Toast); 9279 9280 return Toast; 9281 9282 })); 9283 9284 }(toast$1)); 9285 9286 var toast = toast$1.exports; 9287 9288 /** 9289 * File skip-link-focus-fix.js. 9290 * 9291 * Helps with accessibility for keyboard only users. 9292 * 9293 * Learn more: https://git.io/vWdr2 9294 */ 9295 (function () { 9296 var isWebkit = navigator.userAgent.toLowerCase().indexOf('webkit') > -1, 9297 isOpera = navigator.userAgent.toLowerCase().indexOf('opera') > -1, 9298 isIe = navigator.userAgent.toLowerCase().indexOf('msie') > -1; 9299 9300 if ((isWebkit || isOpera || isIe) && document.getElementById && window.addEventListener) { 9301 window.addEventListener('hashchange', function () { 9302 var id = location.hash.substring(1), 9303 element; 9304 9305 if (!/^[A-z0-9_-]+$/.test(id)) { 9306 return; 9307 } 9308 9309 element = document.getElementById(id); 9310 9311 if (element) { 9312 if (!/^(?:a|select|input|button|textarea)$/i.test(element.tagName)) { 9313 element.tabIndex = -1; 9314 } 9315 9316 element.focus(); 9317 } 9318 }, false); 9319 } 9320 })(); 9321 9322 exports.Alert = alert; 9323 exports.Button = button; 9324 exports.Carousel = carousel; 9325 exports.Collapse = collapse; 9326 exports.Dropdown = dropdown; 9327 exports.Modal = modal; 9328 exports.Offcanvas = offcanvas; 9329 exports.Popover = popover; 9330 exports.Scrollspy = scrollspy; 9331 exports.Tab = tab; 9332 exports.Toast = toast; 9333 exports.Tooltip = tooltip; 9334 9335 Object.defineProperty(exports, '__esModule', { value: true }); 9336 9337})); 9338//# sourceMappingURL=child-theme.js.map
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.