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