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