vendor: 4,383 bytes, lines 1-130
1/*! 2 * Bootstrap v5.2.0 (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.0): 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; 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;
vendor: 4,116 bytes, lines 131-296
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;
vendor: 5,298 bytes, lines 297-451
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.0): 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]); 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)) {
vendor: 4,666 bytes, lines 452-598
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) { 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 || {})) {
vendor: 6,164 bytes, lines 599-832
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.0): 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.0): 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.0): 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.0): 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.0'; 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: 2,511 bytes, lines 833-919
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.0): 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.0): 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';
vendor: 8,809 bytes, lines 920-1265
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.0): 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()` 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.0): 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.0): 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.0): 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}`;
vendor: 16,977 bytes, lines 1266-1880
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)', 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) { 1692 Carousel.getOrCreateInstance(carousel); 1693 } 1694 }); 1695 /** 1696 * jQuery 1697 */ 1698 1699 defineJQueryPlugin(Carousel); 1700 1701 /** 1702 * -------------------------------------------------------------------------- 1703 * Bootstrap (v5.2.0): 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;
vendor: 4,170 bytes, lines 1881-2021
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.0): 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';
vendor: 6,293 bytes, lines 2022-2231
2022 const CLASS_NAME_DROPUP_CENTER = 'dropup-center'; 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 2064 this._menu = SelectorEngine.findOne(SELECTOR_MENU, this._parent); 2065 this._inNavbar = this._detectNavbar(); 2066 } // Getters 2067 2068 2069 static get Default() { 2070 return Default$9; 2071 } 2072 2073 static get DefaultType() { 2074 return DefaultType$9; 2075 } 2076 2077 static get NAME() { 2078 return NAME$a; 2079 } // Public 2080 2081 2082 toggle() { 2083 return this._isShown() ? this.hide() : this.show(); 2084 } 2085 2086 show() { 2087 if (isDisabled(this._element) || this._isShown()) { 2088 return; 2089 } 2090 2091 const relatedTarget = { 2092 relatedTarget: this._element 2093 }; 2094 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$5, relatedTarget); 2095 2096 if (showEvent.defaultPrevented) { 2097 return; 2098 } 2099 2100 this._createPopper(); // If this is a touch-enabled device we add extra 2101 // empty mouseover listeners to the body's immediate children; 2102 // only needed because of broken event delegation on iOS 2103 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 2104 2105 2106 if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) { 2107 for (const element of [].concat(...document.body.children)) { 2108 EventHandler.on(element, 'mouseover', noop); 2109 } 2110 } 2111 2112 this._element.focus(); 2113 2114 this._element.setAttribute('aria-expanded', true); 2115 2116 this._menu.classList.add(CLASS_NAME_SHOW$6); 2117 2118 this._element.classList.add(CLASS_NAME_SHOW$6); 2119 2120 EventHandler.trigger(this._element, EVENT_SHOWN$5, relatedTarget); 2121 } 2122 2123 hide() { 2124 if (isDisabled(this._element) || !this._isShown()) { 2125 return; 2126 } 2127 2128 const relatedTarget = { 2129 relatedTarget: this._element 2130 }; 2131 2132 this._completeHide(relatedTarget); 2133 } 2134 2135 dispose() { 2136 if (this._popper) { 2137 this._popper.destroy(); 2138 } 2139 2140 super.dispose(); 2141 } 2142 2143 update() { 2144 this._inNavbar = this._detectNavbar(); 2145 2146 if (this._popper) { 2147 this._popper.update(); 2148 } 2149 } // Private 2150 2151 2152 _completeHide(relatedTarget) { 2153 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$5, relatedTarget); 2154 2155 if (hideEvent.defaultPrevented) { 2156 return; 2157 } // If this is a touch-enabled device we remove the extra 2158 // empty mouseover listeners we added for iOS support 2159 2160 2161 if ('ontouchstart' in document.documentElement) { 2162 for (const element of [].concat(...document.body.children)) { 2163 EventHandler.off(element, 'mouseover', noop); 2164 } 2165 } 2166 2167 if (this._popper) { 2168 this._popper.destroy(); 2169 } 2170 2171 this._menu.classList.remove(CLASS_NAME_SHOW$6); 2172 2173 this._element.classList.remove(CLASS_NAME_SHOW$6); 2174 2175 this._element.setAttribute('aria-expanded', 'false'); 2176 2177 Manipulator.removeDataAttribute(this._menu, 'popper'); 2178 EventHandler.trigger(this._element, EVENT_HIDDEN$5, relatedTarget); 2179 } 2180 2181 _getConfig(config) { 2182 config = super._getConfig(config); 2183 2184 if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') { 2185 // Popper virtual elements require a getBoundingClientRect method 2186 throw new TypeError(`${NAME$a.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`); 2187 } 2188 2189 return config; 2190 } 2191 2192 _createPopper() { 2193 if (typeof Popper__namespace === 'undefined') { 2194 throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)'); 2195 } 2196 2197 let referenceElement = this._element; 2198 2199 if (this._config.reference === 'parent') { 2200 referenceElement = this._parent; 2201 } else if (isElement(this._config.reference)) { 2202 referenceElement = getElement(this._config.reference); 2203 } else if (typeof this._config.reference === 'object') { 2204 referenceElement = this._config.reference; 2205 } 2206 2207 const popperConfig = this._getPopperConfig(); 2208 2209 this._popper = Popper__namespace.createPopper(referenceElement, this._menu, popperConfig); 2210 } 2211 2212 _isShown() { 2213 return this._menu.classList.contains(CLASS_NAME_SHOW$6); 2214 } 2215 2216 _getPlacement() { 2217 const parentDropdown = this._parent; 2218 2219 if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) { 2220 return PLACEMENT_RIGHT; 2221 } 2222 2223 if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) { 2224 return PLACEMENT_LEFT; 2225 } 2226 2227 if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) { 2228 return PLACEMENT_TOPCENTER; 2229 } 2230 2231 if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENT
vendor: 4,138 bytes, lines 2231-2367
2231ER)) { 2232 return PLACEMENT_BOTTOMCENTER; 2233 } // We need to trim the value because custom properties can also include spaces 2234 2235 2236 const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end'; 2237 2238 if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) { 2239 return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP; 2240 } 2241 2242 return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM; 2243 } 2244 2245 _detectNavbar() { 2246 return this._element.closest(SELECTOR_NAVBAR) !== null; 2247 } 2248 2249 _getOffset() { 2250 const { 2251 offset 2252 } = this._config; 2253 2254 if (typeof offset === 'string') { 2255 return offset.split(',').map(value => Number.parseInt(value, 10)); 2256 } 2257 2258 if (typeof offset === 'function') { 2259 return popperData => offset(popperData, this._element); 2260 } 2261 2262 return offset; 2263 } 2264 2265 _getPopperConfig() { 2266 const defaultBsPopperConfig = { 2267 placement: this._getPlacement(), 2268 modifiers: [{ 2269 name: 'preventOverflow', 2270 options: { 2271 boundary: this._config.boundary 2272 } 2273 }, { 2274 name: 'offset', 2275 options: { 2276 offset: this._getOffset() 2277 } 2278 }] 2279 }; // Disable Popper if we have a static display or Dropdown is in Navbar 2280 2281 if (this._inNavbar || this._config.display === 'static') { 2282 Manipulator.setDataAttribute(this._menu, 'popper', 'static'); // todo:v6 remove 2283 2284 defaultBsPopperConfig.modifiers = [{ 2285 name: 'applyStyles', 2286 enabled: false 2287 }]; 2288 } 2289 2290 return { ...defaultBsPopperConfig, 2291 ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig) 2292 }; 2293 } 2294 2295 _selectMenuItem({ 2296 key, 2297 target 2298 }) { 2299 const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(element => isVisible(element)); 2300 2301 if (!items.length) { 2302 return; 2303 } // if target isn't included in items (e.g. when expanding the dropdown) 2304 // allow cycling to get the last item in case key equals ARROW_UP_KEY 2305 2306 2307 getNextActiveElement(items, target, key === ARROW_DOWN_KEY$1, !items.includes(target)).focus(); 2308 } // Static 2309 2310 2311 static jQueryInterface(config) { 2312 return this.each(function () { 2313 const data = Dropdown.getOrCreateInstance(this, config); 2314 2315 if (typeof config !== 'string') { 2316 return; 2317 } 2318 2319 if (typeof data[config] === 'undefined') { 2320 throw new TypeError(`No method named "${config}"`); 2321 } 2322 2323 data[config](); 2324 }); 2325 } 2326 2327 static clearMenus(event) { 2328 if (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1) { 2329 return; 2330 } 2331 2332 const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN); 2333 2334 for (const toggle of openToggles) { 2335 const context = Dropdown.getInstance(toggle); 2336 2337 if (!context || context._config.autoClose === false) { 2338 continue; 2339 } 2340 2341 const composedPath = event.composedPath(); 2342 const isMenuTarget = composedPath.includes(context._menu); 2343 2344 if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) { 2345 continue; 2346 } // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu 2347 2348 2349 if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) { 2350 continue; 2351 } 2352 2353 const relatedTarget = { 2354 relatedTarget: context._element 2355 }; 2356 2357 if (event.type === 'click') { 2358 relatedTarget.clickEvent = event; 2359 } 2360 2361 context._completeHide(relatedTarget); 2362 } 2363 } 2364 2365 static dataApiKeydownHandler(event) { 2366 // If not an UP | DOWN | ESCAPE key => not a dropdown command 2367 // If input/textarea && if key is other than ESCAPE => not a dropdown command
vendor: 10,400 bytes, lines 2368-2760
2368 const isInput = /input|textarea/i.test(event.target.tagName); 2369 const isEscapeEvent = event.key === ESCAPE_KEY$2; 2370 const isUpOrDownEvent = [ARROW_UP_KEY$1, ARROW_DOWN_KEY$1].includes(event.key); 2371 2372 if (!isUpOrDownEvent && !isEscapeEvent) { 2373 return; 2374 } 2375 2376 if (isInput && !isEscapeEvent) { 2377 return; 2378 } 2379 2380 event.preventDefault(); 2381 const getToggleButton = SelectorEngine.findOne(SELECTOR_DATA_TOGGLE$3, event.delegateTarget.parentNode); 2382 const instance = Dropdown.getOrCreateInstance(getToggleButton); 2383 2384 if (isUpOrDownEvent) { 2385 event.stopPropagation(); 2386 instance.show(); 2387 2388 instance._selectMenuItem(event); 2389 2390 return; 2391 } 2392 2393 if (instance._isShown()) { 2394 // else is escape and we check if it is shown 2395 event.stopPropagation(); 2396 instance.hide(); 2397 getToggleButton.focus(); 2398 } 2399 } 2400 2401 } 2402 /** 2403 * Data API implementation 2404 */ 2405 2406 2407 EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler); 2408 EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler); 2409 EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus); 2410 EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus); 2411 EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) { 2412 event.preventDefault(); 2413 Dropdown.getOrCreateInstance(this).toggle(); 2414 }); 2415 /** 2416 * jQuery 2417 */ 2418 2419 defineJQueryPlugin(Dropdown); 2420 2421 /** 2422 * -------------------------------------------------------------------------- 2423 * Bootstrap (v5.2.0): util/scrollBar.js 2424 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 2425 * -------------------------------------------------------------------------- 2426 */ 2427 /** 2428 * Constants 2429 */ 2430 2431 const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'; 2432 const SELECTOR_STICKY_CONTENT = '.sticky-top'; 2433 const PROPERTY_PADDING = 'padding-right'; 2434 const PROPERTY_MARGIN = 'margin-right'; 2435 /** 2436 * Class definition 2437 */ 2438 2439 class ScrollBarHelper { 2440 constructor() { 2441 this._element = document.body; 2442 } // Public 2443 2444 2445 getWidth() { 2446 // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes 2447 const documentWidth = document.documentElement.clientWidth; 2448 return Math.abs(window.innerWidth - documentWidth); 2449 } 2450 2451 hide() { 2452 const width = this.getWidth(); 2453 2454 this._disableOverFlow(); // give padding to element to balance the hidden scrollbar width 2455 2456 2457 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 2458 2459 2460 this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, calculatedValue => calculatedValue + width); 2461 2462 this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, calculatedValue => calculatedValue - width); 2463 } 2464 2465 reset() { 2466 this._resetElementAttributes(this._element, 'overflow'); 2467 2468 this._resetElementAttributes(this._element, PROPERTY_PADDING); 2469 2470 this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING); 2471 2472 this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN); 2473 } 2474 2475 isOverflowing() { 2476 return this.getWidth() > 0; 2477 } // Private 2478 2479 2480 _disableOverFlow() { 2481 this._saveInitialAttribute(this._element, 'overflow'); 2482 2483 this._element.style.overflow = 'hidden'; 2484 } 2485 2486 _setElementAttributes(selector, styleProperty, callback) { 2487 const scrollbarWidth = this.getWidth(); 2488 2489 const manipulationCallBack = element => { 2490 if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) { 2491 return; 2492 } 2493 2494 this._saveInitialAttribute(element, styleProperty); 2495 2496 const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty); 2497 element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`); 2498 }; 2499 2500 this._applyManipulationCallback(selector, manipulationCallBack); 2501 } 2502 2503 _saveInitialAttribute(element, styleProperty) { 2504 const actualValue = element.style.getPropertyValue(styleProperty); 2505 2506 if (actualValue) { 2507 Manipulator.setDataAttribute(element, styleProperty, actualValue); 2508 } 2509 } 2510 2511 _resetElementAttributes(selector, styleProperty) { 2512 const manipulationCallBack = element => { 2513 const value = Manipulator.getDataAttribute(element, styleProperty); // We only want to remove the property if the value is `null`; the value can also be zero 2514 2515 if (value === null) { 2516 element.style.removeProperty(styleProperty); 2517 return; 2518 } 2519 2520 Manipulator.removeDataAttribute(element, styleProperty); 2521 element.style.setProperty(styleProperty, value); 2522 }; 2523 2524 this._applyManipulationCallback(selector, manipulationCallBack); 2525 } 2526 2527 _applyManipulationCallback(selector, callBack) { 2528 if (isElement(selector)) { 2529 callBack(selector); 2530 return; 2531 } 2532 2533 for (const sel of SelectorEngine.find(selector, this._element)) { 2534 callBack(sel); 2535 } 2536 } 2537 2538 } 2539 2540 /** 2541 * -------------------------------------------------------------------------- 2542 * Bootstrap (v5.2.0): util/backdrop.js 2543 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 2544 * -------------------------------------------------------------------------- 2545 */ 2546 /** 2547 * Constants 2548 */ 2549 2550 const NAME$9 = 'backdrop'; 2551 const CLASS_NAME_FADE$4 = 'fade'; 2552 const CLASS_NAME_SHOW$5 = 'show'; 2553 const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$9}`; 2554 const Default$8 = { 2555 className: 'modal-backdrop', 2556 clickCallback: null, 2557 isAnimated: false, 2558 isVisible: true, 2559 // if false, we use the backdrop helper without adding any element to the dom 2560 rootElement: 'body' // give the choice to place backdrop under different elements 2561 2562 }; 2563 const DefaultType$8 = { 2564 className: 'string', 2565 clickCallback: '(function|null)', 2566 isAnimated: 'boolean', 2567 isVisible: 'boolean', 2568 rootElement: '(element|string)' 2569 }; 2570 /** 2571 * Class definition 2572 */ 2573 2574 class Backdrop extends Config { 2575 constructor(config) { 2576 super(); 2577 this._config = this._getConfig(config); 2578 this._isAppended = false; 2579 this._element = null; 2580 } // Getters 2581 2582 2583 static get Default() { 2584 return Default$8; 2585 } 2586 2587 static get DefaultType() { 2588 return DefaultType$8; 2589 } 2590 2591 static get NAME() { 2592 return NAME$9; 2593 } // Public 2594 2595 2596 show(callback) { 2597 if (!this._config.isVisible) { 2598 execute(callback); 2599 return; 2600 } 2601 2602 this._append(); 2603 2604 const element = this._getElement(); 2605 2606 if (this._config.isAnimated) { 2607 reflow(element); 2608 } 2609 2610 element.classList.add(CLASS_NAME_SHOW$5); 2611 2612 this._emulateAnimation(() => { 2613 execute(callback); 2614 }); 2615 } 2616 2617 hide(callback) { 2618 if (!this._config.isVisible) { 2619 execute(callback); 2620 return; 2621 } 2622 2623 this._getElement().classList.remove(CLASS_NAME_SHOW$5); 2624 2625 this._emulateAnimation(() => { 2626 this.dispose(); 2627 execute(callback); 2628 }); 2629 } 2630 2631 dispose() { 2632 if (!this._isAppended) { 2633 return; 2634 } 2635 2636 EventHandler.off(this._element, EVENT_MOUSEDOWN); 2637 2638 this._element.remove(); 2639 2640 this._isAppended = false; 2641 } // Private 2642 2643 2644 _getElement() { 2645 if (!this._element) { 2646 const backdrop = document.createElement('div'); 2647 backdrop.className = this._config.className; 2648 2649 if (this._config.isAnimated) { 2650 backdrop.classList.add(CLASS_NAME_FADE$4); 2651 } 2652 2653 this._element = backdrop; 2654 } 2655 2656 return this._element; 2657 } 2658 2659 _configAfterMerge(config) { 2660 // use getElement() with the default "body" to get a fresh Element on each instantiation 2661 config.rootElement = getElement(config.rootElement); 2662 return config; 2663 } 2664 2665 _append() { 2666 if (this._isAppended) { 2667 return; 2668 } 2669 2670 const element = this._getElement(); 2671 2672 this._config.rootElement.append(element); 2673 2674 EventHandler.on(element, EVENT_MOUSEDOWN, () => { 2675 execute(this._config.clickCallback); 2676 }); 2677 this._isAppended = true; 2678 } 2679 2680 _emulateAnimation(callback) { 2681 executeAfterTransition(callback, this._getElement(), this._config.isAnimated); 2682 } 2683 2684 } 2685 2686 /** 2687 * -------------------------------------------------------------------------- 2688 * Bootstrap (v5.2.0): util/focustrap.js 2689 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 2690 * -------------------------------------------------------------------------- 2691 */ 2692 /** 2693 * Constants 2694 */ 2695 2696 const NAME$8 = 'focustrap'; 2697 const DATA_KEY$5 = 'bs.focustrap'; 2698 const EVENT_KEY$5 = `.${DATA_KEY$5}`; 2699 const EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$5}`; 2700 const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$5}`; 2701 const TAB_KEY = 'Tab'; 2702 const TAB_NAV_FORWARD = 'forward'; 2703 const TAB_NAV_BACKWARD = 'backward'; 2704 const Default$7 = { 2705 autofocus: true, 2706 trapElement: null // The element to trap focus inside of 2707 2708 }; 2709 const DefaultType$7 = { 2710 autofocus: 'boolean', 2711 trapElement: 'element' 2712 }; 2713 /** 2714 * Class definition 2715 */ 2716 2717 class FocusTrap extends Config { 2718 constructor(config) { 2719 super(); 2720 this._config = this._getConfig(config); 2721 this._isActive = false; 2722 this._lastTabNavDirection = null; 2723 } // Getters 2724 2725 2726 static get Default() { 2727 return Default$7; 2728 } 2729 2730 static get DefaultType() { 2731 return DefaultType$7; 2732 } 2733 2734 static get NAME() { 2735 return NAME$8; 2736 } // Public 2737 2738 2739 activate() { 2740 if (this._isActive) { 2741 return; 2742 } 2743 2744 if (this._config.autofocus) { 2745 this._config.trapElement.focus(); 2746 } 2747 2748 EventHandler.off(document, EVENT_KEY$5); // guard against infinite focus loop 2749 2750 EventHandler.on(document, EVENT_FOCUSIN$2, event => this._handleFocusin(event)); 2751 EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event)); 2752 this._isActive = true; 2753 } 2754 2755 deactivate() { 2756 if (!this._isActive) { 2757 return; 2758 } 2759 2760 this._isActive = false;
2761 EventHandler.off(document, EVENT_KEY$5); 2762 } // Private 2763 2764 2765 _handleFocusin(event) { 2766 const { 2767 trapElement 2768 } = this._config; 2769 2770 if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) { 2771 return; 2772 } 2773 2774 const elements = SelectorEngine.focusableChildren(trapElement); 2775 2776 if (elements.length === 0) { 2777 trapElement.focus(); 2778 } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) { 2779 elements[elements.length - 1].focus(); 2780 } else { 2781 elements[0].focus(); 2782 } 2783 } 2784 2785 _handleKeydown(event) { 2786 if (event.key !== TAB_KEY) { 2787 return; 2788 } 2789 2790 this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD; 2791 } 2792 2793 } 2794 2795 /** 2796 * -------------------------------------------------------------------------- 2797 * Bootstrap (v5.2.0): modal.js 2798 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 2799 * -------------------------------------------------------------------------- 2800 */ 2801 /** 2802 * Constants 2803 */ 2804 2805 const NAME$7 = 'modal'; 2806 const DATA_KEY$4 = 'bs.modal'; 2807 const EVENT_KEY$4 = `.${DATA_KEY$4}`; 2808 const DATA_API_KEY$2 = '.data-api'; 2809 const ESCAPE_KEY$1 = 'Escape'; 2810 const EVENT_HIDE$4 = `hide${EVENT_KEY$4}`; 2811 const EVENT_HIDE_PREVENTED$1 = `hidePrevented${EVENT_KEY$4}`; 2812 const EVENT_HIDDEN$4 = `hidden${EVENT_KEY$4}`; 2813 const EVENT_SHOW$4 = `show${EVENT_KEY$4}`; 2814 const EVENT_SHOWN$4 = `shown${EVENT_KEY$4}`; 2815 const EVENT_RESIZE$1 = `resize${EVENT_KEY$4}`; 2816 const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$4}`; 2817 const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$4}`; 2818 const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$4}${DATA_API_KEY$2}`; 2819 const CLASS_NAME_OPEN = 'modal-open'; 2820 const CLASS_NAME_FADE$3 = 'fade';
vendor: 5,105 bytes, lines 2821-3034
2821 const CLASS_NAME_SHOW$4 = 'show'; 2822 const CLASS_NAME_STATIC = 'modal-static'; 2823 const OPEN_SELECTOR$1 = '.modal.show'; 2824 const SELECTOR_DIALOG = '.modal-dialog'; 2825 const SELECTOR_MODAL_BODY = '.modal-body'; 2826 const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]'; 2827 const Default$6 = { 2828 backdrop: true, 2829 focus: true, 2830 keyboard: true 2831 }; 2832 const DefaultType$6 = { 2833 backdrop: '(boolean|string)', 2834 focus: 'boolean', 2835 keyboard: 'boolean' 2836 }; 2837 /** 2838 * Class definition 2839 */ 2840 2841 class Modal extends BaseComponent { 2842 constructor(element, config) { 2843 super(element, config); 2844 this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element); 2845 this._backdrop = this._initializeBackDrop(); 2846 this._focustrap = this._initializeFocusTrap(); 2847 this._isShown = false; 2848 this._isTransitioning = false; 2849 this._scrollBar = new ScrollBarHelper(); 2850 2851 this._addEventListeners(); 2852 } // Getters 2853 2854 2855 static get Default() { 2856 return Default$6; 2857 } 2858 2859 static get DefaultType() { 2860 return DefaultType$6; 2861 } 2862 2863 static get NAME() { 2864 return NAME$7; 2865 } // Public 2866 2867 2868 toggle(relatedTarget) { 2869 return this._isShown ? this.hide() : this.show(relatedTarget); 2870 } 2871 2872 show(relatedTarget) { 2873 if (this._isShown || this._isTransitioning) { 2874 return; 2875 } 2876 2877 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, { 2878 relatedTarget 2879 }); 2880 2881 if (showEvent.defaultPrevented) { 2882 return; 2883 } 2884 2885 this._isShown = true; 2886 this._isTransitioning = true; 2887 2888 this._scrollBar.hide(); 2889 2890 document.body.classList.add(CLASS_NAME_OPEN); 2891 2892 this._adjustDialog(); 2893 2894 this._backdrop.show(() => this._showElement(relatedTarget)); 2895 } 2896 2897 hide() { 2898 if (!this._isShown || this._isTransitioning) { 2899 return; 2900 } 2901 2902 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4); 2903 2904 if (hideEvent.defaultPrevented) { 2905 return; 2906 } 2907 2908 this._isShown = false; 2909 this._isTransitioning = true; 2910 2911 this._focustrap.deactivate(); 2912 2913 this._element.classList.remove(CLASS_NAME_SHOW$4); 2914 2915 this._queueCallback(() => this._hideModal(), this._element, this._isAnimated()); 2916 } 2917 2918 dispose() { 2919 for (const htmlElement of [window, this._dialog]) { 2920 EventHandler.off(htmlElement, EVENT_KEY$4); 2921 } 2922 2923 this._backdrop.dispose(); 2924 2925 this._focustrap.deactivate(); 2926 2927 super.dispose(); 2928 } 2929 2930 handleUpdate() { 2931 this._adjustDialog(); 2932 } // Private 2933 2934 2935 _initializeBackDrop() { 2936 return new Backdrop({ 2937 isVisible: Boolean(this._config.backdrop), 2938 // 'static' option will be translated to true, and booleans will keep their value, 2939 isAnimated: this._isAnimated() 2940 }); 2941 } 2942 2943 _initializeFocusTrap() { 2944 return new FocusTrap({ 2945 trapElement: this._element 2946 }); 2947 } 2948 2949 _showElement(relatedTarget) { 2950 // try to append dynamic modal 2951 if (!document.body.contains(this._element)) { 2952 document.body.append(this._element); 2953 } 2954 2955 this._element.style.display = 'block'; 2956 2957 this._element.removeAttribute('aria-hidden'); 2958 2959 this._element.setAttribute('aria-modal', true); 2960 2961 this._element.setAttribute('role', 'dialog'); 2962 2963 this._element.scrollTop = 0; 2964 const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog); 2965 2966 if (modalBody) { 2967 modalBody.scrollTop = 0; 2968 } 2969 2970 reflow(this._element); 2971 2972 this._element.classList.add(CLASS_NAME_SHOW$4); 2973 2974 const transitionComplete = () => { 2975 if (this._config.focus) { 2976 this._focustrap.activate(); 2977 } 2978 2979 this._isTransitioning = false; 2980 EventHandler.trigger(this._element, EVENT_SHOWN$4, { 2981 relatedTarget 2982 }); 2983 }; 2984 2985 this._queueCallback(transitionComplete, this._dialog, this._isAnimated()); 2986 } 2987 2988 _addEventListeners() { 2989 EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => { 2990 if (event.key !== ESCAPE_KEY$1) { 2991 return; 2992 } 2993 2994 if (this._config.keyboard) { 2995 event.preventDefault(); 2996 this.hide(); 2997 return; 2998 } 2999 3000 this._triggerBackdropTransition(); 3001 }); 3002 EventHandler.on(window, EVENT_RESIZE$1, () => { 3003 if (this._isShown && !this._isTransitioning) { 3004 this._adjustDialog(); 3005 } 3006 }); 3007 EventHandler.on(this._element, EVENT_MOUSEDOWN_DISMISS, event => { 3008 if (event.target !== event.currentTarget) { 3009 // click is inside modal-dialog 3010 return; 3011 } 3012 3013 if (this._config.backdrop === 'static') { 3014 this._triggerBackdropTransition(); 3015 3016 return; 3017 } 3018 3019 if (this._config.backdrop) { 3020 this.hide(); 3021 } 3022 }); 3023 } 3024 3025 _hideModal() { 3026 this._element.style.display = 'none'; 3027 3028 this._element.setAttribute('aria-hidden', true); 3029 3030 this._element.removeAttribute('aria-modal'); 3031 3032 this._element.removeAttribute('role'); 3033 3034 this._isTransitioning = false;
vendor: 4,100 bytes, lines 3035-3183
3035 3036 this._backdrop.hide(() => { 3037 document.body.classList.remove(CLASS_NAME_OPEN); 3038 3039 this._resetAdjustments(); 3040 3041 this._scrollBar.reset(); 3042 3043 EventHandler.trigger(this._element, EVENT_HIDDEN$4); 3044 }); 3045 } 3046 3047 _isAnimated() { 3048 return this._element.classList.contains(CLASS_NAME_FADE$3); 3049 } 3050 3051 _triggerBackdropTransition() { 3052 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED$1); 3053 3054 if (hideEvent.defaultPrevented) { 3055 return; 3056 } 3057 3058 const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 3059 const initialOverflowY = this._element.style.overflowY; // return if the following background transition hasn't yet completed 3060 3061 if (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) { 3062 return; 3063 } 3064 3065 if (!isModalOverflowing) { 3066 this._element.style.overflowY = 'hidden'; 3067 } 3068 3069 this._element.classList.add(CLASS_NAME_STATIC); 3070 3071 this._queueCallback(() => { 3072 this._element.classList.remove(CLASS_NAME_STATIC); 3073 3074 this._queueCallback(() => { 3075 this._element.style.overflowY = initialOverflowY; 3076 }, this._dialog); 3077 }, this._dialog); 3078 3079 this._element.focus(); 3080 } 3081 /** 3082 * The following methods are used to handle overflowing modals 3083 */ 3084 3085 3086 _adjustDialog() { 3087 const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 3088 3089 const scrollbarWidth = this._scrollBar.getWidth(); 3090 3091 const isBodyOverflowing = scrollbarWidth > 0; 3092 3093 if (isBodyOverflowing && !isModalOverflowing) { 3094 const property = isRTL() ? 'paddingLeft' : 'paddingRight'; 3095 this._element.style[property] = `${scrollbarWidth}px`; 3096 } 3097 3098 if (!isBodyOverflowing && isModalOverflowing) { 3099 const property = isRTL() ? 'paddingRight' : 'paddingLeft'; 3100 this._element.style[property] = `${scrollbarWidth}px`; 3101 } 3102 } 3103 3104 _resetAdjustments() { 3105 this._element.style.paddingLeft = ''; 3106 this._element.style.paddingRight = ''; 3107 } // Static 3108 3109 3110 static jQueryInterface(config, relatedTarget) { 3111 return this.each(function () { 3112 const data = Modal.getOrCreateInstance(this, config); 3113 3114 if (typeof config !== 'string') { 3115 return; 3116 } 3117 3118 if (typeof data[config] === 'undefined') { 3119 throw new TypeError(`No method named "${config}"`); 3120 } 3121 3122 data[config](relatedTarget); 3123 }); 3124 } 3125 3126 } 3127 /** 3128 * Data API implementation 3129 */ 3130 3131 3132 EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) { 3133 const target = getElementFromSelector(this); 3134 3135 if (['A', 'AREA'].includes(this.tagName)) { 3136 event.preventDefault(); 3137 } 3138 3139 EventHandler.one(target, EVENT_SHOW$4, showEvent => { 3140 if (showEvent.defaultPrevented) { 3141 // only register focus restorer if modal will actually get shown 3142 return; 3143 } 3144 3145 EventHandler.one(target, EVENT_HIDDEN$4, () => { 3146 if (isVisible(this)) { 3147 this.focus(); 3148 } 3149 }); 3150 }); // avoid conflict when clicking modal toggler while another one is open 3151 3152 const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1); 3153 3154 if (alreadyOpen) { 3155 Modal.getInstance(alreadyOpen).hide(); 3156 } 3157 3158 const data = Modal.getOrCreateInstance(target); 3159 data.toggle(this); 3160 }); 3161 enableDismissTrigger(Modal); 3162 /** 3163 * jQuery 3164 */ 3165 3166 defineJQueryPlugin(Modal); 3167 3168 /** 3169 * -------------------------------------------------------------------------- 3170 * Bootstrap (v5.2.0): offcanvas.js 3171 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 3172 * -------------------------------------------------------------------------- 3173 */ 3174 /** 3175 * Constants 3176 */ 3177 3178 const NAME$6 = 'offcanvas'; 3179 const DATA_KEY$3 = 'bs.offcanvas'; 3180 const EVENT_KEY$3 = `.${DATA_KEY$3}`; 3181 const DATA_API_KEY$1 = '.data-api'; 3182 const EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$3}${DATA_API_KEY$1}`; 3183 const ESCAPE_KEY = 'Escape';
vendor: 4,885 bytes, lines 3184-3382
3184 const CLASS_NAME_SHOW$3 = 'show'; 3185 const CLASS_NAME_SHOWING$1 = 'showing'; 3186 const CLASS_NAME_HIDING = 'hiding'; 3187 const CLASS_NAME_BACKDROP = 'offcanvas-backdrop'; 3188 const OPEN_SELECTOR = '.offcanvas.show'; 3189 const EVENT_SHOW$3 = `show${EVENT_KEY$3}`; 3190 const EVENT_SHOWN$3 = `shown${EVENT_KEY$3}`; 3191 const EVENT_HIDE$3 = `hide${EVENT_KEY$3}`; 3192 const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$3}`; 3193 const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$3}`; 3194 const EVENT_RESIZE = `resize${EVENT_KEY$3}`; 3195 const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$3}${DATA_API_KEY$1}`; 3196 const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$3}`; 3197 const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]'; 3198 const Default$5 = { 3199 backdrop: true, 3200 keyboard: true, 3201 scroll: false 3202 }; 3203 const DefaultType$5 = { 3204 backdrop: '(boolean|string)', 3205 keyboard: 'boolean', 3206 scroll: 'boolean' 3207 }; 3208 /** 3209 * Class definition 3210 */ 3211 3212 class Offcanvas extends BaseComponent { 3213 constructor(element, config) { 3214 super(element, config); 3215 this._isShown = false; 3216 this._backdrop = this._initializeBackDrop(); 3217 this._focustrap = this._initializeFocusTrap(); 3218 3219 this._addEventListeners(); 3220 } // Getters 3221 3222 3223 static get Default() { 3224 return Default$5; 3225 } 3226 3227 static get DefaultType() { 3228 return DefaultType$5; 3229 } 3230 3231 static get NAME() { 3232 return NAME$6; 3233 } // Public 3234 3235 3236 toggle(relatedTarget) { 3237 return this._isShown ? this.hide() : this.show(relatedTarget); 3238 } 3239 3240 show(relatedTarget) { 3241 if (this._isShown) { 3242 return; 3243 } 3244 3245 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, { 3246 relatedTarget 3247 }); 3248 3249 if (showEvent.defaultPrevented) { 3250 return; 3251 } 3252 3253 this._isShown = true; 3254 3255 this._backdrop.show(); 3256 3257 if (!this._config.scroll) { 3258 new ScrollBarHelper().hide(); 3259 } 3260 3261 this._element.setAttribute('aria-modal', true); 3262 3263 this._element.setAttribute('role', 'dialog'); 3264 3265 this._element.classList.add(CLASS_NAME_SHOWING$1); 3266 3267 const completeCallBack = () => { 3268 if (!this._config.scroll || this._config.backdrop) { 3269 this._focustrap.activate(); 3270 } 3271 3272 this._element.classList.add(CLASS_NAME_SHOW$3); 3273 3274 this._element.classList.remove(CLASS_NAME_SHOWING$1); 3275 3276 EventHandler.trigger(this._element, EVENT_SHOWN$3, { 3277 relatedTarget 3278 }); 3279 }; 3280 3281 this._queueCallback(completeCallBack, this._element, true); 3282 } 3283 3284 hide() { 3285 if (!this._isShown) { 3286 return; 3287 } 3288 3289 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3); 3290 3291 if (hideEvent.defaultPrevented) { 3292 return; 3293 } 3294 3295 this._focustrap.deactivate(); 3296 3297 this._element.blur(); 3298 3299 this._isShown = false; 3300 3301 this._element.classList.add(CLASS_NAME_HIDING); 3302 3303 this._backdrop.hide(); 3304 3305 const completeCallback = () => { 3306 this._element.classList.remove(CLASS_NAME_SHOW$3, CLASS_NAME_HIDING); 3307 3308 this._element.removeAttribute('aria-modal'); 3309 3310 this._element.removeAttribute('role'); 3311 3312 if (!this._config.scroll) { 3313 new ScrollBarHelper().reset(); 3314 } 3315 3316 EventHandler.trigger(this._element, EVENT_HIDDEN$3); 3317 }; 3318 3319 this._queueCallback(completeCallback, this._element, true); 3320 } 3321 3322 dispose() { 3323 this._backdrop.dispose(); 3324 3325 this._focustrap.deactivate(); 3326 3327 super.dispose(); 3328 } // Private 3329 3330 3331 _initializeBackDrop() { 3332 const clickCallback = () => { 3333 if (this._config.backdrop === 'static') { 3334 EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED); 3335 return; 3336 } 3337 3338 this.hide(); 3339 }; // 'static' option will be translated to true, and booleans will keep their value 3340 3341 3342 const isVisible = Boolean(this._config.backdrop); 3343 return new Backdrop({ 3344 className: CLASS_NAME_BACKDROP, 3345 isVisible, 3346 isAnimated: true, 3347 rootElement: this._element.parentNode, 3348 clickCallback: isVisible ? clickCallback : null 3349 }); 3350 } 3351 3352 _initializeFocusTrap() { 3353 return new FocusTrap({ 3354 trapElement: this._element 3355 }); 3356 } 3357 3358 _addEventListeners() { 3359 EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => { 3360 if (event.key !== ESCAPE_KEY) { 3361 return; 3362 } 3363 3364 if (!this._config.keyboard) { 3365 EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED); 3366 return; 3367 } 3368 3369 this.hide(); 3370 }); 3371 } // Static 3372 3373 3374 static jQueryInterface(config) { 3375 return this.each(function () { 3376 const data = Offcanvas.getOrCreateInstance(this, config); 3377 3378 if (typeof config !== 'string') { 3379 return; 3380 } 3381 3382 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
vendor: 9,094 bytes, lines 3383-3717
3383 throw new TypeError(`No method named "${config}"`); 3384 } 3385 3386 data[config](this); 3387 }); 3388 } 3389 3390 } 3391 /** 3392 * Data API implementation 3393 */ 3394 3395 3396 EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) { 3397 const target = getElementFromSelector(this); 3398 3399 if (['A', 'AREA'].includes(this.tagName)) { 3400 event.preventDefault(); 3401 } 3402 3403 if (isDisabled(this)) { 3404 return; 3405 } 3406 3407 EventHandler.one(target, EVENT_HIDDEN$3, () => { 3408 // focus on trigger when it is closed 3409 if (isVisible(this)) { 3410 this.focus(); 3411 } 3412 }); // avoid conflict when clicking a toggler of an offcanvas, while another is open 3413 3414 const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR); 3415 3416 if (alreadyOpen && alreadyOpen !== target) { 3417 Offcanvas.getInstance(alreadyOpen).hide(); 3418 } 3419 3420 const data = Offcanvas.getOrCreateInstance(target); 3421 data.toggle(this); 3422 }); 3423 EventHandler.on(window, EVENT_LOAD_DATA_API$2, () => { 3424 for (const selector of SelectorEngine.find(OPEN_SELECTOR)) { 3425 Offcanvas.getOrCreateInstance(selector).show(); 3426 } 3427 }); 3428 EventHandler.on(window, EVENT_RESIZE, () => { 3429 for (const element of SelectorEngine.find('[aria-modal][class*=show][class*=offcanvas-]')) { 3430 if (getComputedStyle(element).position !== 'fixed') { 3431 Offcanvas.getOrCreateInstance(element).hide(); 3432 } 3433 } 3434 }); 3435 enableDismissTrigger(Offcanvas); 3436 /** 3437 * jQuery 3438 */ 3439 3440 defineJQueryPlugin(Offcanvas); 3441 3442 /** 3443 * -------------------------------------------------------------------------- 3444 * Bootstrap (v5.2.0): util/sanitizer.js 3445 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 3446 * -------------------------------------------------------------------------- 3447 */ 3448 const uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']); 3449 const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i; 3450 /** 3451 * A pattern that recognizes a commonly useful subset of URLs that are safe. 3452 * 3453 * Shout-out to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts 3454 */ 3455 3456 const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i; 3457 /** 3458 * A pattern that matches safe data URLs. Only matches image, video and audio types. 3459 * 3460 * Shout-out to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts 3461 */ 3462 3463 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; 3464 3465 const allowedAttribute = (attribute, allowedAttributeList) => { 3466 const attributeName = attribute.nodeName.toLowerCase(); 3467 3468 if (allowedAttributeList.includes(attributeName)) { 3469 if (uriAttributes.has(attributeName)) { 3470 return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue) || DATA_URL_PATTERN.test(attribute.nodeValue)); 3471 } 3472 3473 return true; 3474 } // Check if a regular expression validates the attribute. 3475 3476 3477 return allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp).some(regex => regex.test(attributeName)); 3478 }; 3479 3480 const DefaultAllowlist = { 3481 // Global attributes allowed on any supplied element below. 3482 '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN], 3483 a: ['target', 'href', 'title', 'rel'], 3484 area: [], 3485 b: [], 3486 br: [], 3487 col: [], 3488 code: [], 3489 div: [], 3490 em: [], 3491 hr: [], 3492 h1: [], 3493 h2: [], 3494 h3: [], 3495 h4: [], 3496 h5: [], 3497 h6: [], 3498 i: [], 3499 img: ['src', 'srcset', 'alt', 'title', 'width', 'height'], 3500 li: [], 3501 ol: [], 3502 p: [], 3503 pre: [], 3504 s: [], 3505 small: [], 3506 span: [], 3507 sub: [], 3508 sup: [], 3509 strong: [], 3510 u: [], 3511 ul: [] 3512 }; 3513 function sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) { 3514 if (!unsafeHtml.length) { 3515 return unsafeHtml; 3516 } 3517 3518 if (sanitizeFunction && typeof sanitizeFunction === 'function') { 3519 return sanitizeFunction(unsafeHtml); 3520 } 3521 3522 const domParser = new window.DOMParser(); 3523 const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); 3524 const elements = [].concat(...createdDocument.body.querySelectorAll('*')); 3525 3526 for (const element of elements) { 3527 const elementName = element.nodeName.toLowerCase(); 3528 3529 if (!Object.keys(allowList).includes(elementName)) { 3530 element.remove(); 3531 continue; 3532 } 3533 3534 const attributeList = [].concat(...element.attributes); 3535 const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []); 3536 3537 for (const attribute of attributeList) { 3538 if (!allowedAttribute(attribute, allowedAttributes)) { 3539 element.removeAttribute(attribute.nodeName); 3540 } 3541 } 3542 } 3543 3544 return createdDocument.body.innerHTML; 3545 } 3546 3547 /** 3548 * -------------------------------------------------------------------------- 3549 * Bootstrap (v5.2.0): util/template-factory.js 3550 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 3551 * -------------------------------------------------------------------------- 3552 */ 3553 /** 3554 * Constants 3555 */ 3556 3557 const NAME$5 = 'TemplateFactory'; 3558 const Default$4 = { 3559 allowList: DefaultAllowlist, 3560 content: {}, 3561 // { selector : text , selector2 : text2 , } 3562 extraClass: '', 3563 html: false, 3564 sanitize: true, 3565 sanitizeFn: null, 3566 template: '<div></div>' 3567 }; 3568 const DefaultType$4 = { 3569 allowList: 'object', 3570 content: 'object', 3571 extraClass: '(string|function)', 3572 html: 'boolean', 3573 sanitize: 'boolean', 3574 sanitizeFn: '(null|function)', 3575 template: 'string' 3576 }; 3577 const DefaultContentType = { 3578 entry: '(string|element|function|null)', 3579 selector: '(string|element)' 3580 }; 3581 /** 3582 * Class definition 3583 */ 3584 3585 class TemplateFactory extends Config { 3586 constructor(config) { 3587 super(); 3588 this._config = this._getConfig(config); 3589 } // Getters 3590 3591 3592 static get Default() { 3593 return Default$4; 3594 } 3595 3596 static get DefaultType() { 3597 return DefaultType$4; 3598 } 3599 3600 static get NAME() { 3601 return NAME$5; 3602 } // Public 3603 3604 3605 getContent() { 3606 return Object.values(this._config.content).map(config => this._resolvePossibleFunction(config)).filter(Boolean); 3607 } 3608 3609 hasContent() { 3610 return this.getContent().length > 0; 3611 } 3612 3613 changeContent(content) { 3614 this._checkContent(content); 3615 3616 this._config.content = { ...this._config.content, 3617 ...content 3618 }; 3619 return this; 3620 } 3621 3622 toHtml() { 3623 const templateWrapper = document.createElement('div'); 3624 templateWrapper.innerHTML = this._maybeSanitize(this._config.template); 3625 3626 for (const [selector, text] of Object.entries(this._config.content)) { 3627 this._setContent(templateWrapper, text, selector); 3628 } 3629 3630 const template = templateWrapper.children[0]; 3631 3632 const extraClass = this._resolvePossibleFunction(this._config.extraClass); 3633 3634 if (extraClass) { 3635 template.classList.add(...extraClass.split(' ')); 3636 } 3637 3638 return template; 3639 } // Private 3640 3641 3642 _typeCheckConfig(config) { 3643 super._typeCheckConfig(config); 3644 3645 this._checkContent(config.content); 3646 } 3647 3648 _checkContent(arg) { 3649 for (const [selector, content] of Object.entries(arg)) { 3650 super._typeCheckConfig({ 3651 selector, 3652 entry: content 3653 }, DefaultContentType); 3654 } 3655 } 3656 3657 _setContent(template, content, selector) { 3658 const templateElement = SelectorEngine.findOne(selector, template); 3659 3660 if (!templateElement) { 3661 return; 3662 } 3663 3664 content = this._resolvePossibleFunction(content); 3665 3666 if (!content) { 3667 templateElement.remove(); 3668 return; 3669 } 3670 3671 if (isElement(content)) { 3672 this._putElementInTemplate(getElement(content), templateElement); 3673 3674 return; 3675 } 3676 3677 if (this._config.html) { 3678 templateElement.innerHTML = this._maybeSanitize(content); 3679 return; 3680 } 3681 3682 templateElement.textContent = content; 3683 } 3684 3685 _maybeSanitize(arg) { 3686 return this._config.sanitize ? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn) : arg; 3687 } 3688 3689 _resolvePossibleFunction(arg) { 3690 return typeof arg === 'function' ? arg(this) : arg; 3691 } 3692 3693 _putElementInTemplate(element, templateElement) { 3694 if (this._config.html) { 3695 templateElement.innerHTML = ''; 3696 templateElement.append(element); 3697 return; 3698 } 3699 3700 templateElement.textContent = element.textContent; 3701 } 3702 3703 } 3704 3705 /** 3706 * -------------------------------------------------------------------------- 3707 * Bootstrap (v5.2.0): tooltip.js 3708 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 3709 * -------------------------------------------------------------------------- 3710 */ 3711 /** 3712 * Constants 3713 */ 3714 3715 const NAME$4 = 'tooltip'; 3716 const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']); 3717 const CLASS_NAME_FADE$2 = 'fade';
vendor: 4,856 bytes, lines 3718-3911
3718 const CLASS_NAME_MODAL = 'modal'; 3719 const CLASS_NAME_SHOW$2 = 'show'; 3720 const SELECTOR_TOOLTIP_INNER = '.tooltip-inner'; 3721 const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`; 3722 const EVENT_MODAL_HIDE = 'hide.bs.modal'; 3723 const TRIGGER_HOVER = 'hover'; 3724 const TRIGGER_FOCUS = 'focus'; 3725 const TRIGGER_CLICK = 'click'; 3726 const TRIGGER_MANUAL = 'manual'; 3727 const EVENT_HIDE$2 = 'hide'; 3728 const EVENT_HIDDEN$2 = 'hidden'; 3729 const EVENT_SHOW$2 = 'show'; 3730 const EVENT_SHOWN$2 = 'shown'; 3731 const EVENT_INSERTED = 'inserted'; 3732 const EVENT_CLICK$1 = 'click'; 3733 const EVENT_FOCUSIN$1 = 'focusin'; 3734 const EVENT_FOCUSOUT$1 = 'focusout'; 3735 const EVENT_MOUSEENTER = 'mouseenter'; 3736 const EVENT_MOUSELEAVE = 'mouseleave'; 3737 const AttachmentMap = { 3738 AUTO: 'auto', 3739 TOP: 'top', 3740 RIGHT: isRTL() ? 'left' : 'right', 3741 BOTTOM: 'bottom', 3742 LEFT: isRTL() ? 'right' : 'left' 3743 }; 3744 const Default$3 = { 3745 allowList: DefaultAllowlist, 3746 animation: true, 3747 boundary: 'clippingParents', 3748 container: false, 3749 customClass: '', 3750 delay: 0, 3751 fallbackPlacements: ['top', 'right', 'bottom', 'left'], 3752 html: false, 3753 offset: [0, 0], 3754 placement: 'top', 3755 popperConfig: null, 3756 sanitize: true, 3757 sanitizeFn: null, 3758 selector: false, 3759 template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>', 3760 title: '', 3761 trigger: 'hover focus' 3762 }; 3763 const DefaultType$3 = { 3764 allowList: 'object', 3765 animation: 'boolean', 3766 boundary: '(string|element)', 3767 container: '(string|element|boolean)', 3768 customClass: '(string|function)', 3769 delay: '(number|object)', 3770 fallbackPlacements: 'array', 3771 html: 'boolean', 3772 offset: '(array|string|function)', 3773 placement: '(string|function)', 3774 popperConfig: '(null|object|function)', 3775 sanitize: 'boolean', 3776 sanitizeFn: '(null|function)', 3777 selector: '(string|boolean)', 3778 template: 'string', 3779 title: '(string|element|function)', 3780 trigger: 'string' 3781 }; 3782 /** 3783 * Class definition 3784 */ 3785 3786 class Tooltip extends BaseComponent { 3787 constructor(element, config) { 3788 if (typeof Popper__namespace === 'undefined') { 3789 throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)'); 3790 } 3791 3792 super(element, config); // Private 3793 3794 this._isEnabled = true; 3795 this._timeout = 0; 3796 this._isHovered = false; 3797 this._activeTrigger = {}; 3798 this._popper = null; 3799 this._templateFactory = null; 3800 this._newContent = null; // Protected 3801 3802 this.tip = null; 3803 3804 this._setListeners(); 3805 } // Getters 3806 3807 3808 static get Default() { 3809 return Default$3; 3810 } 3811 3812 static get DefaultType() { 3813 return DefaultType$3; 3814 } 3815 3816 static get NAME() { 3817 return NAME$4; 3818 } // Public 3819 3820 3821 enable() { 3822 this._isEnabled = true; 3823 } 3824 3825 disable() { 3826 this._isEnabled = false; 3827 } 3828 3829 toggleEnabled() { 3830 this._isEnabled = !this._isEnabled; 3831 } 3832 3833 toggle(event) { 3834 if (!this._isEnabled) { 3835 return; 3836 } 3837 3838 if (event) { 3839 const context = this._initializeOnDelegatedTarget(event); 3840 3841 context._activeTrigger.click = !context._activeTrigger.click; 3842 3843 if (context._isWithActiveTrigger()) { 3844 context._enter(); 3845 } else { 3846 context._leave(); 3847 } 3848 3849 return; 3850 } 3851 3852 if (this._isShown()) { 3853 this._leave(); 3854 3855 return; 3856 } 3857 3858 this._enter(); 3859 } 3860 3861 dispose() { 3862 clearTimeout(this._timeout); 3863 EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler); 3864 3865 if (this.tip) { 3866 this.tip.remove(); 3867 } 3868 3869 this._disposePopper(); 3870 3871 super.dispose(); 3872 } 3873 3874 show() { 3875 if (this._element.style.display === 'none') { 3876 throw new Error('Please use show on visible elements'); 3877 } 3878 3879 if (!(this._isWithContent() && this._isEnabled)) { 3880 return; 3881 } 3882 3883 const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW$2)); 3884 const shadowRoot = findShadowRoot(this._element); 3885 3886 const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element); 3887 3888 if (showEvent.defaultPrevented || !isInTheDom) { 3889 return; 3890 } // todo v6 remove this OR make it optional 3891 3892 3893 if (this.tip) { 3894 this.tip.remove(); 3895 this.tip = null; 3896 } 3897 3898 const tip = this._getTipElement(); 3899 3900 this._element.setAttribute('aria-describedby', tip.getAttribute('id')); 3901 3902 const { 3903 container 3904 } = this._config; 3905 3906 if (!this._element.ownerDocument.documentElement.contains(this.tip)) { 3907 container.append(tip); 3908 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED)); 3909 } 3910 3911 if (this._popper) {
vendor: 3,006 bytes, lines 3912-4017
3912 this._popper.update(); 3913 } else { 3914 this._popper = this._createPopper(tip); 3915 } 3916 3917 tip.classList.add(CLASS_NAME_SHOW$2); // If this is a touch-enabled device we add extra 3918 // empty mouseover listeners to the body's immediate children; 3919 // only needed because of broken event delegation on iOS 3920 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 3921 3922 if ('ontouchstart' in document.documentElement) { 3923 for (const element of [].concat(...document.body.children)) { 3924 EventHandler.on(element, 'mouseover', noop); 3925 } 3926 } 3927 3928 const complete = () => { 3929 const previousHoverState = this._isHovered; 3930 this._isHovered = false; 3931 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOWN$2)); 3932 3933 if (previousHoverState) { 3934 this._leave(); 3935 } 3936 }; 3937 3938 this._queueCallback(complete, this.tip, this._isAnimated()); 3939 } 3940 3941 hide() { 3942 if (!this._isShown()) { 3943 return; 3944 } 3945 3946 const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE$2)); 3947 3948 if (hideEvent.defaultPrevented) { 3949 return; 3950 } 3951 3952 const tip = this._getTipElement(); 3953 3954 tip.classList.remove(CLASS_NAME_SHOW$2); // If this is a touch-enabled device we remove the extra 3955 // empty mouseover listeners we added for iOS support 3956 3957 if ('ontouchstart' in document.documentElement) { 3958 for (const element of [].concat(...document.body.children)) { 3959 EventHandler.off(element, 'mouseover', noop); 3960 } 3961 } 3962 3963 this._activeTrigger[TRIGGER_CLICK] = false; 3964 this._activeTrigger[TRIGGER_FOCUS] = false; 3965 this._activeTrigger[TRIGGER_HOVER] = false; 3966 this._isHovered = false; 3967 3968 const complete = () => { 3969 if (this._isWithActiveTrigger()) { 3970 return; 3971 } 3972 3973 if (!this._isHovered) { 3974 tip.remove(); 3975 } 3976 3977 this._element.removeAttribute('aria-describedby'); 3978 3979 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDDEN$2)); 3980 3981 this._disposePopper(); 3982 }; 3983 3984 this._queueCallback(complete, this.tip, this._isAnimated()); 3985 } 3986 3987 update() { 3988 if (this._popper) { 3989 this._popper.update(); 3990 } 3991 } // Protected 3992 3993 3994 _isWithContent() { 3995 return Boolean(this._getTitle()); 3996 } 3997 3998 _getTipElement() { 3999 if (!this.tip) { 4000 this.tip = this._createTipElement(this._newContent || this._getContentForTemplate()); 4001 } 4002 4003 return this.tip; 4004 } 4005 4006 _createTipElement(content) { 4007 const tip = this._getTemplateFactory(content).toHtml(); // todo: remove this check on v6 4008 4009 4010 if (!tip) { 4011 return null; 4012 } 4013 4014 tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2); // todo: on v6 the following can be achieved with CSS only 4015 4016 tip.classList.add(`bs-${this.constructor.NAME}-auto`); 4017 const tipId = getUID(this.constructor.NAME).toString();
vendor: 5,933 bytes, lines 4018-4218
4018 tip.setAttribute('id', tipId); 4019 4020 if (this._isAnimated()) { 4021 tip.classList.add(CLASS_NAME_FADE$2); 4022 } 4023 4024 return tip; 4025 } 4026 4027 setContent(content) { 4028 this._newContent = content; 4029 4030 if (this._isShown()) { 4031 this._disposePopper(); 4032 4033 this.show(); 4034 } 4035 } 4036 4037 _getTemplateFactory(content) { 4038 if (this._templateFactory) { 4039 this._templateFactory.changeContent(content); 4040 } else { 4041 this._templateFactory = new TemplateFactory({ ...this._config, 4042 // the `content` var has to be after `this._config` 4043 // to override config.content in case of popover 4044 content, 4045 extraClass: this._resolvePossibleFunction(this._config.customClass) 4046 }); 4047 } 4048 4049 return this._templateFactory; 4050 } 4051 4052 _getContentForTemplate() { 4053 return { 4054 [SELECTOR_TOOLTIP_INNER]: this._getTitle() 4055 }; 4056 } 4057 4058 _getTitle() { 4059 return this._resolvePossibleFunction(this._config.title) || this._config.originalTitle; 4060 } // Private 4061 4062 4063 _initializeOnDelegatedTarget(event) { 4064 return this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig()); 4065 } 4066 4067 _isAnimated() { 4068 return this._config.animation || this.tip && this.tip.classList.contains(CLASS_NAME_FADE$2); 4069 } 4070 4071 _isShown() { 4072 return this.tip && this.tip.classList.contains(CLASS_NAME_SHOW$2); 4073 } 4074 4075 _createPopper(tip) { 4076 const placement = typeof this._config.placement === 'function' ? this._config.placement.call(this, tip, this._element) : this._config.placement; 4077 const attachment = AttachmentMap[placement.toUpperCase()]; 4078 return Popper__namespace.createPopper(this._element, tip, this._getPopperConfig(attachment)); 4079 } 4080 4081 _getOffset() { 4082 const { 4083 offset 4084 } = this._config; 4085 4086 if (typeof offset === 'string') { 4087 return offset.split(',').map(value => Number.parseInt(value, 10)); 4088 } 4089 4090 if (typeof offset === 'function') { 4091 return popperData => offset(popperData, this._element); 4092 } 4093 4094 return offset; 4095 } 4096 4097 _resolvePossibleFunction(arg) { 4098 return typeof arg === 'function' ? arg.call(this._element) : arg; 4099 } 4100 4101 _getPopperConfig(attachment) { 4102 const defaultBsPopperConfig = { 4103 placement: attachment, 4104 modifiers: [{ 4105 name: 'flip', 4106 options: { 4107 fallbackPlacements: this._config.fallbackPlacements 4108 } 4109 }, { 4110 name: 'offset', 4111 options: { 4112 offset: this._getOffset() 4113 } 4114 }, { 4115 name: 'preventOverflow', 4116 options: { 4117 boundary: this._config.boundary 4118 } 4119 }, { 4120 name: 'arrow', 4121 options: { 4122 element: `.${this.constructor.NAME}-arrow` 4123 } 4124 }, { 4125 name: 'preSetPlacement', 4126 enabled: true, 4127 phase: 'beforeMain', 4128 fn: data => { 4129 // Pre-set Popper's placement attribute in order to read the arrow sizes properly. 4130 // Otherwise, Popper mixes up the width and height dimensions since the initial arrow style is for top placement 4131 this._getTipElement().setAttribute('data-popper-placement', data.state.placement); 4132 } 4133 }] 4134 }; 4135 return { ...defaultBsPopperConfig, 4136 ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig) 4137 }; 4138 } 4139 4140 _setListeners() { 4141 const triggers = this._config.trigger.split(' '); 4142 4143 for (const trigger of triggers) { 4144 if (trigger === 'click') { 4145 EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK$1), this._config.selector, event => this.toggle(event)); 4146 } else if (trigger !== TRIGGER_MANUAL) { 4147 const eventIn = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSEENTER) : this.constructor.eventName(EVENT_FOCUSIN$1); 4148 const eventOut = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSELEAVE) : this.constructor.eventName(EVENT_FOCUSOUT$1); 4149 EventHandler.on(this._element, eventIn, this._config.selector, event => { 4150 const context = this._initializeOnDelegatedTarget(event); 4151 4152 context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true; 4153 4154 context._enter(); 4155 }); 4156 EventHandler.on(this._element, eventOut, this._config.selector, event => { 4157 const context = this._initializeOnDelegatedTarget(event); 4158 4159 context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget); 4160 4161 context._leave(); 4162 }); 4163 } 4164 } 4165 4166 this._hideModalHandler = () => { 4167 if (this._element) { 4168 this.hide(); 4169 } 4170 }; 4171 4172 EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler); 4173 4174 if (this._config.selector) { 4175 this._config = { ...this._config, 4176 trigger: 'manual', 4177 selector: '' 4178 }; 4179 } else { 4180 this._fixTitle(); 4181 } 4182 } 4183 4184 _fixTitle() { 4185 const title = this._config.originalTitle; 4186 4187 if (!title) { 4188 return; 4189 } 4190 4191 if (!this._element.getAttribute('aria-label') && !this._element.textContent.trim()) { 4192 this._element.setAttribute('aria-label', title); 4193 } 4194 4195 this._element.removeAttribute('title'); 4196 } 4197 4198 _enter() { 4199 if (this._isShown() || this._isHovered) { 4200 this._isHovered = true; 4201 return; 4202 } 4203 4204 this._isHovered = true; 4205 4206 this._setTimeout(() => { 4207 if (this._isHovered) { 4208 this.show(); 4209 } 4210 }, this._config.delay.show); 4211 } 4212 4213 _leave() { 4214 if (this._isWithActiveTrigger()) { 4215 return; 4216 } 4217 4218 this._isHovered = false;
vendor: 4,314 bytes, lines 4219-4394
4219 4220 this._setTimeout(() => { 4221 if (!this._isHovered) { 4222 this.hide(); 4223 } 4224 }, this._config.delay.hide); 4225 } 4226 4227 _setTimeout(handler, timeout) { 4228 clearTimeout(this._timeout); 4229 this._timeout = setTimeout(handler, timeout); 4230 } 4231 4232 _isWithActiveTrigger() { 4233 return Object.values(this._activeTrigger).includes(true); 4234 } 4235 4236 _getConfig(config) { 4237 const dataAttributes = Manipulator.getDataAttributes(this._element); 4238 4239 for (const dataAttribute of Object.keys(dataAttributes)) { 4240 if (DISALLOWED_ATTRIBUTES.has(dataAttribute)) { 4241 delete dataAttributes[dataAttribute]; 4242 } 4243 } 4244 4245 config = { ...dataAttributes, 4246 ...(typeof config === 'object' && config ? config : {}) 4247 }; 4248 config = this._mergeConfigObj(config); 4249 config = this._configAfterMerge(config); 4250 4251 this._typeCheckConfig(config); 4252 4253 return config; 4254 } 4255 4256 _configAfterMerge(config) { 4257 config.container = config.container === false ? document.body : getElement(config.container); 4258 4259 if (typeof config.delay === 'number') { 4260 config.delay = { 4261 show: config.delay, 4262 hide: config.delay 4263 }; 4264 } 4265 4266 config.originalTitle = this._element.getAttribute('title') || ''; 4267 4268 if (typeof config.title === 'number') { 4269 config.title = config.title.toString(); 4270 } 4271 4272 if (typeof config.content === 'number') { 4273 config.content = config.content.toString(); 4274 } 4275 4276 return config; 4277 } 4278 4279 _getDelegateConfig() { 4280 const config = {}; 4281 4282 for (const key in this._config) { 4283 if (this.constructor.Default[key] !== this._config[key]) { 4284 config[key] = this._config[key]; 4285 } 4286 } // 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 4291 return config; 4292 } 4293 4294 _disposePopper() { 4295 if (this._popper) { 4296 this._popper.destroy(); 4297 4298 this._popper = null; 4299 } 4300 } // Static 4301 4302 4303 static jQueryInterface(config) { 4304 return this.each(function () { 4305 const data = Tooltip.getOrCreateInstance(this, config); 4306 4307 if (typeof config !== 'string') { 4308 return; 4309 } 4310 4311 if (typeof data[config] === 'undefined') { 4312 throw new TypeError(`No method named "${config}"`); 4313 } 4314 4315 data[config](); 4316 }); 4317 } 4318 4319 } 4320 /** 4321 * jQuery 4322 */ 4323 4324 4325 defineJQueryPlugin(Tooltip); 4326 4327 /** 4328 * -------------------------------------------------------------------------- 4329 * Bootstrap (v5.2.0): popover.js 4330 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4331 * -------------------------------------------------------------------------- 4332 */ 4333 /** 4334 * Constants 4335 */ 4336 4337 const NAME$3 = 'popover'; 4338 const SELECTOR_TITLE = '.popover-header'; 4339 const SELECTOR_CONTENT = '.popover-body'; 4340 const Default$2 = { ...Tooltip.Default, 4341 content: '', 4342 offset: [0, 8], 4343 placement: 'right', 4344 template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>', 4345 trigger: 'click' 4346 }; 4347 const DefaultType$2 = { ...Tooltip.DefaultType, 4348 content: '(null|string|element|function)' 4349 }; 4350 /** 4351 * Class definition 4352 */ 4353 4354 class Popover extends Tooltip { 4355 // Getters 4356 static get Default() { 4357 return Default$2; 4358 } 4359 4360 static get DefaultType() { 4361 return DefaultType$2; 4362 } 4363 4364 static get NAME() { 4365 return NAME$3; 4366 } // Overrides 4367 4368 4369 _isWithContent() { 4370 return this._getTitle() || this._getContent(); 4371 } // Private 4372 4373 4374 _getContentForTemplate() { 4375 return { 4376 [SELECTOR_TITLE]: this._getTitle(), 4377 [SELECTOR_CONTENT]: this._getContent() 4378 }; 4379 } 4380 4381 _getContent() { 4382 return this._resolvePossibleFunction(this._config.content); 4383 } // Static 4384 4385 4386 static jQueryInterface(config) { 4387 return this.each(function () { 4388 const data = Popover.getOrCreateInstance(this, config); 4389 4390 if (typeof config !== 'string') { 4391 return; 4392 } 4393 4394 if (typeof data[config] === 'undefined') {
vendor: 4,959 bytes, lines 4395-4566
4395 throw new TypeError(`No method named "${config}"`); 4396 } 4397 4398 data[config](); 4399 }); 4400 } 4401 4402 } 4403 /** 4404 * jQuery 4405 */ 4406 4407 4408 defineJQueryPlugin(Popover); 4409 4410 /** 4411 * -------------------------------------------------------------------------- 4412 * Bootstrap (v5.2.0): scrollspy.js 4413 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4414 * -------------------------------------------------------------------------- 4415 */ 4416 /** 4417 * Constants 4418 */ 4419 4420 const NAME$2 = 'scrollspy'; 4421 const DATA_KEY$2 = 'bs.scrollspy'; 4422 const EVENT_KEY$2 = `.${DATA_KEY$2}`; 4423 const DATA_API_KEY = '.data-api'; 4424 const EVENT_ACTIVATE = `activate${EVENT_KEY$2}`; 4425 const EVENT_CLICK = `click${EVENT_KEY$2}`; 4426 const EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$2}${DATA_API_KEY}`; 4427 const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item'; 4428 const CLASS_NAME_ACTIVE$1 = 'active'; 4429 const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]'; 4430 const SELECTOR_TARGET_LINKS = '[href]'; 4431 const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'; 4432 const SELECTOR_NAV_LINKS = '.nav-link'; 4433 const SELECTOR_NAV_ITEMS = '.nav-item'; 4434 const SELECTOR_LIST_ITEMS = '.list-group-item'; 4435 const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`; 4436 const SELECTOR_DROPDOWN = '.dropdown'; 4437 const SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle'; 4438 const Default$1 = { 4439 offset: null, 4440 // TODO: v6 @deprecated, keep it for backwards compatibility reasons 4441 rootMargin: '0px 0px -25%', 4442 smoothScroll: false, 4443 target: null 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 }; 4452 /** 4453 * Class definition 4454 */ 4455 4456 class ScrollSpy extends BaseComponent { 4457 constructor(element, config) { 4458 super(element, config); // this._element is the observablesContainer and config.target the menu links wrapper 4459 4460 this._targetLinks = new Map(); 4461 this._observableSections = new Map(); 4462 this._rootElement = getComputedStyle(this._element).overflowY === 'visible' ? null : this._element; 4463 this._activeTarget = null; 4464 this._observer = null; 4465 this._previousScrollData = { 4466 visibleEntryTop: 0, 4467 parentScrollTop: 0 4468 }; 4469 this.refresh(); // initialize 4470 } // Getters 4471 4472 4473 static get Default() { 4474 return Default$1; 4475 } 4476 4477 static get DefaultType() { 4478 return DefaultType$1; 4479 } 4480 4481 static get NAME() { 4482 return NAME$2; 4483 } // Public 4484 4485 4486 refresh() { 4487 this._initializeTargetsAndObservables(); 4488 4489 this._maybeEnableSmoothScroll(); 4490 4491 if (this._observer) { 4492 this._observer.disconnect(); 4493 } else { 4494 this._observer = this._getNewObserver(); 4495 } 4496 4497 for (const section of this._observableSections.values()) { 4498 this._observer.observe(section); 4499 } 4500 } 4501 4502 dispose() { 4503 this._observer.disconnect(); 4504 4505 super.dispose(); 4506 } // Private 4507 4508 4509 _configAfterMerge(config) { 4510 // TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case 4511 config.target = getElement(config.target) || document.body; 4512 return config; 4513 } 4514 4515 _maybeEnableSmoothScroll() { 4516 if (!this._config.smoothScroll) { 4517 return; 4518 } // unregister any previous listeners 4519 4520 4521 EventHandler.off(this._config.target, EVENT_CLICK); 4522 EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, event => { 4523 const observableSection = this._observableSections.get(event.target.hash); 4524 4525 if (observableSection) { 4526 event.preventDefault(); 4527 const root = this._rootElement || window; 4528 const height = observableSection.offsetTop - this._element.offsetTop; 4529 4530 if (root.scrollTo) { 4531 root.scrollTo({ 4532 top: height, 4533 behavior: 'smooth' 4534 }); 4535 return; 4536 } // Chrome 60 doesn't support `scrollTo` 4537 4538 4539 root.scrollTop = height; 4540 } 4541 }); 4542 } 4543 4544 _getNewObserver() { 4545 const options = { 4546 root: this._rootElement, 4547 threshold: [0.1, 0.5, 1], 4548 rootMargin: this._getRootMargin() 4549 }; 4550 return new IntersectionObserver(entries => this._observerCallback(entries), options); 4551 } // The logic of selection 4552 4553 4554 _observerCallback(entries) { 4555 const targetElement = entry => this._targetLinks.get(`#${entry.target.id}`); 4556 4557 const activate = entry => { 4558 this._previousScrollData.visibleEntryTop = entry.target.offsetTop; 4559 4560 this._process(targetElement(entry)); 4561 }; 4562 4563 const parentScrollTop = (this._rootElement || document.documentElement).scrollTop; 4564 const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop; 4565 this._previousScrollData.parentScrollTop = parentScrollTop; 4566
vendor: 4,783 bytes, lines 4567-4722
4567 for (const entry of entries) { 4568 if (!entry.isIntersecting) { 4569 this._activeTarget = null; 4570 4571 this._clearActiveClass(targetElement(entry)); 4572 4573 continue; 4574 } 4575 4576 const entryIsLowerThanPrevious = entry.target.offsetTop >= this._previousScrollData.visibleEntryTop; // if we are scrolling down, pick the bigger offsetTop 4577 4578 if (userScrollsDown && entryIsLowerThanPrevious) { 4579 activate(entry); // if parent isn't scrolled, let's keep the first visible item, breaking the iteration 4580 4581 if (!parentScrollTop) { 4582 return; 4583 } 4584 4585 continue; 4586 } // if we are scrolling up, pick the smallest offsetTop 4587 4588 4589 if (!userScrollsDown && !entryIsLowerThanPrevious) { 4590 activate(entry); 4591 } 4592 } 4593 } // TODO: v6 Only for backwards compatibility reasons. Use rootMargin only 4594 4595 4596 _getRootMargin() { 4597 return this._config.offset ? `${this._config.offset}px 0px -30%` : this._config.rootMargin; 4598 } 4599 4600 _initializeTargetsAndObservables() { 4601 this._targetLinks = new Map(); 4602 this._observableSections = new Map(); 4603 const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target); 4604 4605 for (const anchor of targetLinks) { 4606 // ensure that the anchor has an id and is not disabled 4607 if (!anchor.hash || isDisabled(anchor)) { 4608 continue; 4609 } 4610 4611 const observableSection = SelectorEngine.findOne(anchor.hash, this._element); // ensure that the observableSection exists & is visible 4612 4613 if (isVisible(observableSection)) { 4614 this._targetLinks.set(anchor.hash, anchor); 4615 4616 this._observableSections.set(anchor.hash, observableSection); 4617 } 4618 } 4619 } 4620 4621 _process(target) { 4622 if (this._activeTarget === target) { 4623 return; 4624 } 4625 4626 this._clearActiveClass(this._config.target); 4627 4628 this._activeTarget = target; 4629 target.classList.add(CLASS_NAME_ACTIVE$1); 4630 4631 this._activateParents(target); 4632 4633 EventHandler.trigger(this._element, EVENT_ACTIVATE, { 4634 relatedTarget: target 4635 }); 4636 } 4637 4638 _activateParents(target) { 4639 // Activate dropdown parents 4640 if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) { 4641 SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, target.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$1); 4642 return; 4643 } 4644 4645 for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) { 4646 // Set triggered links parents as active 4647 // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor 4648 for (const item of SelectorEngine.prev(listGroup, SELECTOR_LINK_ITEMS)) { 4649 item.classList.add(CLASS_NAME_ACTIVE$1); 4650 } 4651 } 4652 } 4653 4654 _clearActiveClass(parent) { 4655 parent.classList.remove(CLASS_NAME_ACTIVE$1); 4656 const activeNodes = SelectorEngine.find(`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE$1}`, parent); 4657 4658 for (const node of activeNodes) { 4659 node.classList.remove(CLASS_NAME_ACTIVE$1); 4660 } 4661 } // Static 4662 4663 4664 static jQueryInterface(config) { 4665 return this.each(function () { 4666 const data = ScrollSpy.getOrCreateInstance(this, config); 4667 4668 if (typeof config !== 'string') { 4669 return; 4670 } 4671 4672 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 4673 throw new TypeError(`No method named "${config}"`); 4674 } 4675 4676 data[config](); 4677 }); 4678 } 4679 4680 } 4681 /** 4682 * Data API implementation 4683 */ 4684 4685 4686 EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => { 4687 for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) { 4688 ScrollSpy.getOrCreateInstance(spy); 4689 } 4690 }); 4691 /** 4692 * jQuery 4693 */ 4694 4695 defineJQueryPlugin(ScrollSpy); 4696 4697 /** 4698 * -------------------------------------------------------------------------- 4699 * Bootstrap (v5.2.0): tab.js 4700 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4701 * -------------------------------------------------------------------------- 4702 */ 4703 /** 4704 * Constants 4705 */ 4706 4707 const NAME$1 = 'tab'; 4708 const DATA_KEY$1 = 'bs.tab'; 4709 const EVENT_KEY$1 = `.${DATA_KEY$1}`; 4710 const EVENT_HIDE$1 = `hide${EVENT_KEY$1}`; 4711 const EVENT_HIDDEN$1 = `hidden${EVENT_KEY$1}`; 4712 const EVENT_SHOW$1 = `show${EVENT_KEY$1}`; 4713 const EVENT_SHOWN$1 = `shown${EVENT_KEY$1}`; 4714 const EVENT_CLICK_DATA_API = `click${EVENT_KEY$1}`; 4715 const EVENT_KEYDOWN = `keydown${EVENT_KEY$1}`; 4716 const EVENT_LOAD_DATA_API = `load${EVENT_KEY$1}`; 4717 const ARROW_LEFT_KEY = 'ArrowLeft'; 4718 const ARROW_RIGHT_KEY = 'ArrowRight'; 4719 const ARROW_UP_KEY = 'ArrowUp'; 4720 const ARROW_DOWN_KEY = 'ArrowDown'; 4721 const CLASS_NAME_ACTIVE = 'active'; 4722 const CLASS_NAME_FADE$1 = 'fade';
vendor: 5,985 bytes, lines 4723-4919
4723 const CLASS_NAME_SHOW$1 = 'show'; 4724 const CLASS_DROPDOWN = 'dropdown'; 4725 const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'; 4726 const SELECTOR_DROPDOWN_MENU = '.dropdown-menu'; 4727 const SELECTOR_DROPDOWN_ITEM = '.dropdown-item'; 4728 const NOT_SELECTOR_DROPDOWN_TOGGLE = ':not(.dropdown-toggle)'; 4729 const SELECTOR_TAB_PANEL = '.list-group, .nav, [role="tablist"]'; 4730 const SELECTOR_OUTER = '.nav-item, .list-group-item'; 4731 const SELECTOR_INNER = `.nav-link${NOT_SELECTOR_DROPDOWN_TOGGLE}, .list-group-item${NOT_SELECTOR_DROPDOWN_TOGGLE}, [role="tab"]${NOT_SELECTOR_DROPDOWN_TOGGLE}`; 4732 const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]'; // todo:v6: could be only `tab` 4733 4734 const SELECTOR_INNER_ELEM = `${SELECTOR_INNER}, ${SELECTOR_DATA_TOGGLE}`; 4735 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"]`; 4736 /** 4737 * Class definition 4738 */ 4739 4740 class Tab extends BaseComponent { 4741 constructor(element) { 4742 super(element); 4743 this._parent = this._element.closest(SELECTOR_TAB_PANEL); 4744 4745 if (!this._parent) { 4746 return; // todo: should Throw exception on v6 4747 // throw new TypeError(`${element.outerHTML} has not a valid parent ${SELECTOR_INNER_ELEM}`) 4748 } // Set up initial aria attributes 4749 4750 4751 this._setInitialAttributes(this._parent, this._getChildren()); 4752 4753 EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event)); 4754 } // Getters 4755 4756 4757 static get NAME() { 4758 return NAME$1; 4759 } // Public 4760 4761 4762 show() { 4763 // Shows this elem and deactivate the active sibling if exists 4764 const innerElem = this._element; 4765 4766 if (this._elemIsActive(innerElem)) { 4767 return; 4768 } // Search for active tab on same parent to deactivate it 4769 4770 4771 const active = this._getActiveElem(); 4772 4773 const hideEvent = active ? EventHandler.trigger(active, EVENT_HIDE$1, { 4774 relatedTarget: innerElem 4775 }) : null; 4776 const showEvent = EventHandler.trigger(innerElem, EVENT_SHOW$1, { 4777 relatedTarget: active 4778 }); 4779 4780 if (showEvent.defaultPrevented || hideEvent && hideEvent.defaultPrevented) { 4781 return; 4782 } 4783 4784 this._deactivate(active, innerElem); 4785 4786 this._activate(innerElem, active); 4787 } // Private 4788 4789 4790 _activate(element, relatedElem) { 4791 if (!element) { 4792 return; 4793 } 4794 4795 element.classList.add(CLASS_NAME_ACTIVE); 4796 4797 this._activate(getElementFromSelector(element)); // Search and activate/show the proper section 4798 4799 4800 const complete = () => { 4801 if (element.getAttribute('role') !== 'tab') { 4802 element.classList.add(CLASS_NAME_SHOW$1); 4803 return; 4804 } 4805 4806 element.focus(); 4807 element.removeAttribute('tabindex'); 4808 element.setAttribute('aria-selected', true); 4809 4810 this._toggleDropDown(element, true); 4811 4812 EventHandler.trigger(element, EVENT_SHOWN$1, { 4813 relatedTarget: relatedElem 4814 }); 4815 }; 4816 4817 this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1)); 4818 } 4819 4820 _deactivate(element, relatedElem) { 4821 if (!element) { 4822 return; 4823 } 4824 4825 element.classList.remove(CLASS_NAME_ACTIVE); 4826 element.blur(); 4827 4828 this._deactivate(getElementFromSelector(element)); // Search and deactivate the shown section too 4829 4830 4831 const complete = () => { 4832 if (element.getAttribute('role') !== 'tab') { 4833 element.classList.remove(CLASS_NAME_SHOW$1); 4834 return; 4835 } 4836 4837 element.setAttribute('aria-selected', false); 4838 element.setAttribute('tabindex', '-1'); 4839 4840 this._toggleDropDown(element, false); 4841 4842 EventHandler.trigger(element, EVENT_HIDDEN$1, { 4843 relatedTarget: relatedElem 4844 }); 4845 }; 4846 4847 this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1)); 4848 } 4849 4850 _keydown(event) { 4851 if (![ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY].includes(event.key)) { 4852 return; 4853 } 4854 4855 event.stopPropagation(); // stopPropagation/preventDefault both added to support up/down keys without scrolling the page 4856 4857 event.preventDefault(); 4858 const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key); 4859 const nextActiveElement = getNextActiveElement(this._getChildren().filter(element => !isDisabled(element)), event.target, isNext, true); 4860 4861 if (nextActiveElement) { 4862 Tab.getOrCreateInstance(nextActiveElement).show(); 4863 } 4864 } 4865 4866 _getChildren() { 4867 // collection of inner elements 4868 return SelectorEngine.find(SELECTOR_INNER_ELEM, this._parent); 4869 } 4870 4871 _getActiveElem() { 4872 return this._getChildren().find(child => this._elemIsActive(child)) || null; 4873 } 4874 4875 _setInitialAttributes(parent, children) { 4876 this._setAttributeIfNotExists(parent, 'role', 'tablist'); 4877 4878 for (const child of children) { 4879 this._setInitialAttributesOnChild(child); 4880 } 4881 } 4882 4883 _setInitialAttributesOnChild(child) { 4884 child = this._getInnerElement(child); 4885 4886 const isActive = this._elemIsActive(child); 4887 4888 const outerElem = this._getOuterElement(child); 4889 4890 child.setAttribute('aria-selected', isActive); 4891 4892 if (outerElem !== child) { 4893 this._setAttributeIfNotExists(outerElem, 'role', 'presentation'); 4894 } 4895 4896 if (!isActive) { 4897 child.setAttribute('tabindex', '-1'); 4898 } 4899 4900 this._setAttributeIfNotExists(child, 'role', 'tab'); // set attributes to the related panel too 4901 4902 4903 this._setInitialAttributesOnTargetPanel(child); 4904 } 4905 4906 _setInitialAttributesOnTargetPanel(child) { 4907 const target = getElementFromSelector(child); 4908 4909 if (!target) { 4910 return; 4911 } 4912 4913 this._setAttributeIfNotExists(target, 'role', 'tabpanel'); 4914 4915 if (child.id) { 4916 this._setAttributeIfNotExists(target, 'aria-labelledby', `#${child.id}`); 4917 } 4918 } 4919
vendor: 7,110 bytes, lines 4920-5205
4920 _toggleDropDown(element, open) { 4921 const outerElem = this._getOuterElement(element); 4922 4923 if (!outerElem.classList.contains(CLASS_DROPDOWN)) { 4924 return; 4925 } 4926 4927 const toggle = (selector, className) => { 4928 const element = SelectorEngine.findOne(selector, outerElem); 4929 4930 if (element) { 4931 element.classList.toggle(className, open); 4932 } 4933 }; 4934 4935 toggle(SELECTOR_DROPDOWN_TOGGLE, CLASS_NAME_ACTIVE); 4936 toggle(SELECTOR_DROPDOWN_MENU, CLASS_NAME_SHOW$1); 4937 toggle(SELECTOR_DROPDOWN_ITEM, CLASS_NAME_ACTIVE); 4938 outerElem.setAttribute('aria-expanded', open); 4939 } 4940 4941 _setAttributeIfNotExists(element, attribute, value) { 4942 if (!element.hasAttribute(attribute)) { 4943 element.setAttribute(attribute, value); 4944 } 4945 } 4946 4947 _elemIsActive(elem) { 4948 return elem.classList.contains(CLASS_NAME_ACTIVE); 4949 } // Try to get the inner element (usually the .nav-link) 4950 4951 4952 _getInnerElement(elem) { 4953 return elem.matches(SELECTOR_INNER_ELEM) ? elem : SelectorEngine.findOne(SELECTOR_INNER_ELEM, elem); 4954 } // Try to get the outer element (usually the .nav-item) 4955 4956 4957 _getOuterElement(elem) { 4958 return elem.closest(SELECTOR_OUTER) || elem; 4959 } // Static 4960 4961 4962 static jQueryInterface(config) { 4963 return this.each(function () { 4964 const data = Tab.getOrCreateInstance(this); 4965 4966 if (typeof config !== 'string') { 4967 return; 4968 } 4969 4970 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 4971 throw new TypeError(`No method named "${config}"`); 4972 } 4973 4974 data[config](); 4975 }); 4976 } 4977 4978 } 4979 /** 4980 * Data API implementation 4981 */ 4982 4983 4984 EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { 4985 if (['A', 'AREA'].includes(this.tagName)) { 4986 event.preventDefault(); 4987 } 4988 4989 if (isDisabled(this)) { 4990 return; 4991 } 4992 4993 Tab.getOrCreateInstance(this).show(); 4994 }); 4995 /** 4996 * Initialize on focus 4997 */ 4998 4999 EventHandler.on(window, EVENT_LOAD_DATA_API, () => { 5000 for (const element of SelectorEngine.find(SELECTOR_DATA_TOGGLE_ACTIVE)) { 5001 Tab.getOrCreateInstance(element); 5002 } 5003 }); 5004 /** 5005 * jQuery 5006 */ 5007 5008 defineJQueryPlugin(Tab); 5009 5010 /** 5011 * -------------------------------------------------------------------------- 5012 * Bootstrap (v5.2.0): toast.js 5013 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5014 * -------------------------------------------------------------------------- 5015 */ 5016 /** 5017 * Constants 5018 */ 5019 5020 const NAME = 'toast'; 5021 const DATA_KEY = 'bs.toast'; 5022 const EVENT_KEY = `.${DATA_KEY}`; 5023 const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`; 5024 const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`; 5025 const EVENT_FOCUSIN = `focusin${EVENT_KEY}`; 5026 const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`; 5027 const EVENT_HIDE = `hide${EVENT_KEY}`; 5028 const EVENT_HIDDEN = `hidden${EVENT_KEY}`; 5029 const EVENT_SHOW = `show${EVENT_KEY}`; 5030 const EVENT_SHOWN = `shown${EVENT_KEY}`; 5031 const CLASS_NAME_FADE = 'fade'; 5032 const CLASS_NAME_HIDE = 'hide'; // @deprecated - kept here only for backwards compatibility 5033 5034 const CLASS_NAME_SHOW = 'show'; 5035 const CLASS_NAME_SHOWING = 'showing'; 5036 const DefaultType = { 5037 animation: 'boolean', 5038 autohide: 'boolean', 5039 delay: 'number' 5040 }; 5041 const Default = { 5042 animation: true, 5043 autohide: true, 5044 delay: 5000 5045 }; 5046 /** 5047 * Class definition 5048 */ 5049 5050 class Toast extends BaseComponent { 5051 constructor(element, config) { 5052 super(element, config); 5053 this._timeout = null; 5054 this._hasMouseInteraction = false; 5055 this._hasKeyboardInteraction = false; 5056 5057 this._setListeners(); 5058 } // Getters 5059 5060 5061 static get Default() { 5062 return Default; 5063 } 5064 5065 static get DefaultType() { 5066 return DefaultType; 5067 } 5068 5069 static get NAME() { 5070 return NAME; 5071 } // Public 5072 5073 5074 show() { 5075 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW); 5076 5077 if (showEvent.defaultPrevented) { 5078 return; 5079 } 5080 5081 this._clearTimeout(); 5082 5083 if (this._config.animation) { 5084 this._element.classList.add(CLASS_NAME_FADE); 5085 } 5086 5087 const complete = () => { 5088 this._element.classList.remove(CLASS_NAME_SHOWING); 5089 5090 EventHandler.trigger(this._element, EVENT_SHOWN); 5091 5092 this._maybeScheduleHide(); 5093 }; 5094 5095 this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated 5096 5097 5098 reflow(this._element); 5099 5100 this._element.classList.add(CLASS_NAME_SHOW, CLASS_NAME_SHOWING); 5101 5102 this._queueCallback(complete, this._element, this._config.animation); 5103 } 5104 5105 hide() { 5106 if (!this.isShown()) { 5107 return; 5108 } 5109 5110 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE); 5111 5112 if (hideEvent.defaultPrevented) { 5113 return; 5114 } 5115 5116 const complete = () => { 5117 this._element.classList.add(CLASS_NAME_HIDE); // @deprecated 5118 5119 5120 this._element.classList.remove(CLASS_NAME_SHOWING, CLASS_NAME_SHOW); 5121 5122 EventHandler.trigger(this._element, EVENT_HIDDEN); 5123 }; 5124 5125 this._element.classList.add(CLASS_NAME_SHOWING); 5126 5127 this._queueCallback(complete, this._element, this._config.animation); 5128 } 5129 5130 dispose() { 5131 this._clearTimeout(); 5132 5133 if (this.isShown()) { 5134 this._element.classList.remove(CLASS_NAME_SHOW); 5135 } 5136 5137 super.dispose(); 5138 } 5139 5140 isShown() { 5141 return this._element.classList.contains(CLASS_NAME_SHOW); 5142 } // Private 5143 5144 5145 _maybeScheduleHide() { 5146 if (!this._config.autohide) { 5147 return; 5148 } 5149 5150 if (this._hasMouseInteraction || this._hasKeyboardInteraction) { 5151 return; 5152 } 5153 5154 this._timeout = setTimeout(() => { 5155 this.hide(); 5156 }, this._config.delay); 5157 } 5158 5159 _onInteraction(event, isInteracting) { 5160 switch (event.type) { 5161 case 'mouseover': 5162 case 'mouseout': 5163 this._hasMouseInteraction = isInteracting; 5164 break; 5165 5166 case 'focusin': 5167 case 'focusout': 5168 this._hasKeyboardInteraction = isInteracting; 5169 break; 5170 } 5171 5172 if (isInteracting) { 5173 this._clearTimeout(); 5174 5175 return; 5176 } 5177 5178 const nextElement = event.relatedTarget; 5179 5180 if (this._element === nextElement || this._element.contains(nextElement)) { 5181 return; 5182 } 5183 5184 this._maybeScheduleHide(); 5185 } 5186 5187 _setListeners() { 5188 EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true)); 5189 EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false)); 5190 EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true)); 5191 EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false)); 5192 } 5193 5194 _clearTimeout() { 5195 clearTimeout(this._timeout); 5196 this._timeout = null; 5197 } // Static 5198 5199 5200 static jQueryInterface(config) { 5201 return this.each(function () { 5202 const data = Toast.getOrCreateInstance(this, config); 5203 5204 if (typeof config === 'string') { 5205 if (typeof data[config] === 'undefined') {
5206 throw new TypeError(`No method named "${config}"`); 5207 } 5208 5209 data[config](this); 5210 } 5211 }); 5212 } 5213 5214 } 5215 /** 5216 * Data API implementation 5217 */ 5218 5219 5220 enableDismissTrigger(Toast); 5221 /** 5222 * jQuery 5223 */ 5224 5225 defineJQueryPlugin(Toast); 5226 5227 /** 5228 * -------------------------------------------------------------------------- 5229 * Bootstrap (v5.2.0): index.umd.js 5230 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5231 * -------------------------------------------------------------------------- 5232 */ 5233 const index_umd = { 5234 Alert, 5235 Button, 5236 Carousel, 5237 Collapse, 5238 Dropdown, 5239 Modal, 5240 Offcanvas, 5241 Popover, 5242 ScrollSpy, 5243 Tab, 5244 Toast, 5245 Tooltip 5246 }; 5247 5248 return index_umd; 5249 5250})); 5251//# 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.