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