vendor: 8,227 bytes, lines 1-253
1/*! 2 * Bootstrap v5.3.3 (https://getbootstrap.com/) 3 * Copyright 2011-2024 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() : 8 typeof define === 'function' && define.amd ? define(factory) : 9 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.bootstrap = factory()); 10})(this, (function () { 'use strict'; 11 12 /** 13 * -------------------------------------------------------------------------- 14 * Bootstrap dom/data.js 15 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 16 * -------------------------------------------------------------------------- 17 */ 18 19 /** 20 * Constants 21 */ 22 23 const elementMap = new Map(); 24 const Data = { 25 set(element, key, instance) { 26 if (!elementMap.has(element)) { 27 elementMap.set(element, new Map()); 28 } 29 const instanceMap = elementMap.get(element); 30 31 // make it clear we only want one instance per element 32 // can be removed later when multiple key/instances are fine to be used 33 if (!instanceMap.has(key) && instanceMap.size !== 0) { 34 // eslint-disable-next-line no-console 35 console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`); 36 return; 37 } 38 instanceMap.set(key, instance); 39 }, 40 get(element, key) { 41 if (elementMap.has(element)) { 42 return elementMap.get(element).get(key) || null; 43 } 44 return null; 45 }, 46 remove(element, key) { 47 if (!elementMap.has(element)) { 48 return; 49 } 50 const instanceMap = elementMap.get(element); 51 instanceMap.delete(key); 52 53 // free up element references if there are no instances left for an element 54 if (instanceMap.size === 0) { 55 elementMap.delete(element); 56 } 57 } 58 }; 59 60 /** 61 * -------------------------------------------------------------------------- 62 * Bootstrap util/index.js 63 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 64 * -------------------------------------------------------------------------- 65 */ 66 67 const MAX_UID = 1000000; 68 const MILLISECONDS_MULTIPLIER = 1000; 69 const TRANSITION_END = 'transitionend'; 70 71 /** 72 * Properly escape IDs selectors to handle weird IDs 73 * @param {string} selector 74 * @returns {string} 75 */ 76 const parseSelector = selector => { 77 if (selector && window.CSS && window.CSS.escape) { 78 // document.querySelector needs escaping to handle IDs (html5+) containing for instance / 79 selector = selector.replace(/#([^\s"#']+)/g, (match, id) => `#${CSS.escape(id)}`); 80 } 81 return selector; 82 }; 83 84 // Shout-out Angus Croll (https://goo.gl/pxwQGp) 85 const toType = object => { 86 if (object === null || object === undefined) { 87 return `${object}`; 88 } 89 return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase(); 90 }; 91 92 /** 93 * Public Util API 94 */ 95 96 const getUID = prefix => { 97 do { 98 prefix += Math.floor(Math.random() * MAX_UID); 99 } while (document.getElementById(prefix)); 100 return prefix; 101 }; 102 const getTransitionDurationFromElement = element => { 103 if (!element) { 104 return 0; 105 } 106 107 // Get transition-duration of the element 108 let { 109 transitionDuration, 110 transitionDelay 111 } = window.getComputedStyle(element); 112 const floatTransitionDuration = Number.parseFloat(transitionDuration); 113 const floatTransitionDelay = Number.parseFloat(transitionDelay); 114 115 // Return 0 if element or transition duration is not found 116 if (!floatTransitionDuration && !floatTransitionDelay) { 117 return 0; 118 } 119 120 // If multiple durations are defined, take the first 121 transitionDuration = transitionDuration.split(',')[0]; 122 transitionDelay = transitionDelay.split(',')[0]; 123 return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; 124 }; 125 const triggerTransitionEnd = element => { 126 element.dispatchEvent(new Event(TRANSITION_END)); 127 }; 128 const isElement$1 = object => { 129 if (!object || typeof object !== 'object') { 130 return false; 131 } 132 if (typeof object.jquery !== 'undefined') { 133 object = object[0]; 134 } 135 return typeof object.nodeType !== 'undefined'; 136 }; 137 const getElement = object => { 138 // it's a jQuery object or a node element 139 if (isElement$1(object)) { 140 return object.jquery ? object[0] : object; 141 } 142 if (typeof object === 'string' && object.length > 0) { 143 return document.querySelector(parseSelector(object)); 144 } 145 return null; 146 }; 147 const isVisible = element => { 148 if (!isElement$1(element) || element.getClientRects().length === 0) { 149 return false; 150 } 151 const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible'; 152 // Handle `details` element as its content may falsie appear visible when it is closed 153 const closedDetails = element.closest('details:not([open])'); 154 if (!closedDetails) { 155 return elementIsVisible; 156 } 157 if (closedDetails !== element) { 158 const summary = element.closest('summary'); 159 if (summary && summary.parentNode !== closedDetails) { 160 return false; 161 } 162 if (summary === null) { 163 return false; 164 } 165 } 166 return elementIsVisible; 167 }; 168 const isDisabled = element => { 169 if (!element || element.nodeType !== Node.ELEMENT_NODE) { 170 return true; 171 } 172 if (element.classList.contains('disabled')) { 173 return true; 174 } 175 if (typeof element.disabled !== 'undefined') { 176 return element.disabled; 177 } 178 return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'; 179 }; 180 const findShadowRoot = element => { 181 if (!document.documentElement.attachShadow) { 182 return null; 183 } 184 185 // Can find the shadow root otherwise it'll return the document 186 if (typeof element.getRootNode === 'function') { 187 const root = element.getRootNode(); 188 return root instanceof ShadowRoot ? root : null; 189 } 190 if (element instanceof ShadowRoot) { 191 return element; 192 } 193 194 // when we don't find a shadow root 195 if (!element.parentNode) { 196 return null; 197 } 198 return findShadowRoot(element.parentNode); 199 }; 200 const noop = () => {}; 201 202 /** 203 * Trick to restart an element's animation 204 * 205 * @param {HTMLElement} element 206 * @return void 207 * 208 * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation 209 */ 210 const reflow = element => { 211 element.offsetHeight; // eslint-disable-line no-unused-expressions 212 }; 213 const getjQuery = () => { 214 if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 215 return window.jQuery; 216 } 217 return null; 218 }; 219 const DOMContentLoadedCallbacks = []; 220 const onDOMContentLoaded = callback => { 221 if (document.readyState === 'loading') { 222 // add listener on the first call when the document is in loading state 223 if (!DOMContentLoadedCallbacks.length) { 224 document.addEventListener('DOMContentLoaded', () => { 225 for (const callback of DOMContentLoadedCallbacks) { 226 callback(); 227 } 228 }); 229 } 230 DOMContentLoadedCallbacks.push(callback); 231 } else { 232 callback(); 233 } 234 }; 235 const isRTL = () => document.documentElement.dir === 'rtl'; 236 const defineJQueryPlugin = plugin => { 237 onDOMContentLoaded(() => { 238 const $ = getjQuery(); 239 /* istanbul ignore if */ 240 if ($) { 241 const name = plugin.NAME; 242 const JQUERY_NO_CONFLICT = $.fn[name]; 243 $.fn[name] = plugin.jQueryInterface; 244 $.fn[name].Constructor = plugin; 245 $.fn[name].noConflict = () => { 246 $.fn[name] = JQUERY_NO_CONFLICT; 247 return plugin.jQueryInterface; 248 }; 249 } 250 }); 251 }; 252 const execute = (possibleCallback, args = [], defaultValue = possibleCallback) => { 253 return typeof possibleCallback === 'function' ? possibleCallback
vendor: 5,610 bytes, lines 253-398
253(...args) : defaultValue; 254 }; 255 const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => { 256 if (!waitForTransition) { 257 execute(callback); 258 return; 259 } 260 const durationPadding = 5; 261 const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding; 262 let called = false; 263 const handler = ({ 264 target 265 }) => { 266 if (target !== transitionElement) { 267 return; 268 } 269 called = true; 270 transitionElement.removeEventListener(TRANSITION_END, handler); 271 execute(callback); 272 }; 273 transitionElement.addEventListener(TRANSITION_END, handler); 274 setTimeout(() => { 275 if (!called) { 276 triggerTransitionEnd(transitionElement); 277 } 278 }, emulatedDuration); 279 }; 280 281 /** 282 * Return the previous/next element of a list. 283 * 284 * @param {array} list The list of elements 285 * @param activeElement The active element 286 * @param shouldGetNext Choose to get next or previous element 287 * @param isCycleAllowed 288 * @return {Element|elem} The proper element 289 */ 290 const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => { 291 const listLength = list.length; 292 let index = list.indexOf(activeElement); 293 294 // if the element does not exist in the list return an element 295 // depending on the direction and if cycle is allowed 296 if (index === -1) { 297 return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0]; 298 } 299 index += shouldGetNext ? 1 : -1; 300 if (isCycleAllowed) { 301 index = (index + listLength) % listLength; 302 } 303 return list[Math.max(0, Math.min(index, listLength - 1))]; 304 }; 305 306 /** 307 * -------------------------------------------------------------------------- 308 * Bootstrap dom/event-handler.js 309 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 310 * -------------------------------------------------------------------------- 311 */ 312 313 314 /** 315 * Constants 316 */ 317 318 const namespaceRegex = /[^.]*(?=\..*)\.|.*/; 319 const stripNameRegex = /\..*/; 320 const stripUidRegex = /::\d+$/; 321 const eventRegistry = {}; // Events storage 322 let uidEvent = 1; 323 const customEvents = { 324 mouseenter: 'mouseover', 325 mouseleave: 'mouseout' 326 }; 327 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']); 328 329 /** 330 * Private methods 331 */ 332 333 function makeEventUid(element, uid) { 334 return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++; 335 } 336 function getElementEvents(element) { 337 const uid = makeEventUid(element); 338 element.uidEvent = uid; 339 eventRegistry[uid] = eventRegistry[uid] || {}; 340 return eventRegistry[uid]; 341 } 342 function bootstrapHandler(element, fn) { 343 return function handler(event) { 344 hydrateObj(event, { 345 delegateTarget: element 346 }); 347 if (handler.oneOff) { 348 EventHandler.off(element, event.type, fn); 349 } 350 return fn.apply(element, [event]); 351 }; 352 } 353 function bootstrapDelegationHandler(element, selector, fn) { 354 return function handler(event) { 355 const domElements = element.querySelectorAll(selector); 356 for (let { 357 target 358 } = event; target && target !== this; target = target.parentNode) { 359 for (const domElement of domElements) { 360 if (domElement !== target) { 361 continue; 362 } 363 hydrateObj(event, { 364 delegateTarget: target 365 }); 366 if (handler.oneOff) { 367 EventHandler.off(element, event.type, selector, fn); 368 } 369 return fn.apply(target, [event]); 370 } 371 } 372 }; 373 } 374 function findHandler(events, callable, delegationSelector = null) { 375 return Object.values(events).find(event => event.callable === callable && event.delegationSelector === delegationSelector); 376 } 377 function normalizeParameters(originalTypeEvent, handler, delegationFunction) { 378 const isDelegated = typeof handler === 'string'; 379 // TODO: tooltip passes `false` instead of selector, so we need to check 380 const callable = isDelegated ? delegationFunction : handler || delegationFunction; 381 let typeEvent = getTypeEvent(originalTypeEvent); 382 if (!nativeEvents.has(typeEvent)) { 383 typeEvent = originalTypeEvent; 384 } 385 return [isDelegated, callable, typeEvent]; 386 } 387 function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) { 388 if (typeof originalTypeEvent !== 'string' || !element) { 389 return; 390 } 391 let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction); 392 393 // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position 394 // this prevents the handler from being dispatched the same way as mouseover or mouseout does 395 if (originalTypeEvent in customEvents) { 396 const wrapFunction = fn => { 397 return function (event) { 398 if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
vendor: 4,866 bytes, lines 399-530
399 return fn.call(this, event); 400 } 401 }; 402 }; 403 callable = wrapFunction(callable); 404 } 405 const events = getElementEvents(element); 406 const handlers = events[typeEvent] || (events[typeEvent] = {}); 407 const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null); 408 if (previousFunction) { 409 previousFunction.oneOff = previousFunction.oneOff && oneOff; 410 return; 411 } 412 const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, '')); 413 const fn = isDelegated ? bootstrapDelegationHandler(element, handler, callable) : bootstrapHandler(element, callable); 414 fn.delegationSelector = isDelegated ? handler : null; 415 fn.callable = callable; 416 fn.oneOff = oneOff; 417 fn.uidEvent = uid; 418 handlers[uid] = fn; 419 element.addEventListener(typeEvent, fn, isDelegated); 420 } 421 function removeHandler(element, events, typeEvent, handler, delegationSelector) { 422 const fn = findHandler(events[typeEvent], handler, delegationSelector); 423 if (!fn) { 424 return; 425 } 426 element.removeEventListener(typeEvent, fn, Boolean(delegationSelector)); 427 delete events[typeEvent][fn.uidEvent]; 428 } 429 function removeNamespacedHandlers(element, events, typeEvent, namespace) { 430 const storeElementEvent = events[typeEvent] || {}; 431 for (const [handlerKey, event] of Object.entries(storeElementEvent)) { 432 if (handlerKey.includes(namespace)) { 433 removeHandler(element, events, typeEvent, event.callable, event.delegationSelector); 434 } 435 } 436 } 437 function getTypeEvent(event) { 438 // allow to get the native events from namespaced events ('click.bs.button' --> 'click') 439 event = event.replace(stripNameRegex, ''); 440 return customEvents[event] || event; 441 } 442 const EventHandler = { 443 on(element, event, handler, delegationFunction) { 444 addHandler(element, event, handler, delegationFunction, false); 445 }, 446 one(element, event, handler, delegationFunction) { 447 addHandler(element, event, handler, delegationFunction, true); 448 }, 449 off(element, originalTypeEvent, handler, delegationFunction) { 450 if (typeof originalTypeEvent !== 'string' || !element) { 451 return; 452 } 453 const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction); 454 const inNamespace = typeEvent !== originalTypeEvent; 455 const events = getElementEvents(element); 456 const storeElementEvent = events[typeEvent] || {}; 457 const isNamespace = originalTypeEvent.startsWith('.'); 458 if (typeof callable !== 'undefined') { 459 // Simplest case: handler is passed, remove that listener ONLY. 460 if (!Object.keys(storeElementEvent).length) { 461 return; 462 } 463 removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null); 464 return; 465 } 466 if (isNamespace) { 467 for (const elementEvent of Object.keys(events)) { 468 removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1)); 469 } 470 } 471 for (const [keyHandlers, event] of Object.entries(storeElementEvent)) { 472 const handlerKey = keyHandlers.replace(stripUidRegex, ''); 473 if (!inNamespace || originalTypeEvent.includes(handlerKey)) { 474 removeHandler(element, events, typeEvent, event.callable, event.delegationSelector); 475 } 476 } 477 }, 478 trigger(element, event, args) { 479 if (typeof event !== 'string' || !element) { 480 return null; 481 } 482 const $ = getjQuery(); 483 const typeEvent = getTypeEvent(event); 484 const inNamespace = event !== typeEvent; 485 let jQueryEvent = null; 486 let bubbles = true; 487 let nativeDispatch = true; 488 let defaultPrevented = false; 489 if (inNamespace && $) { 490 jQueryEvent = $.Event(event, args); 491 $(element).trigger(jQueryEvent); 492 bubbles = !jQueryEvent.isPropagationStopped(); 493 nativeDispatch = !jQueryEvent.isImmediatePropagationStopped(); 494 defaultPrevented = jQueryEvent.isDefaultPrevented(); 495 } 496 const evt = hydrateObj(new Event(event, { 497 bubbles, 498 cancelable: true 499 }), args); 500 if (defaultPrevented) { 501 evt.preventDefault(); 502 } 503 if (nativeDispatch) { 504 element.dispatchEvent(evt); 505 } 506 if (evt.defaultPrevented && jQueryEvent) { 507 jQueryEvent.preventDefault(); 508 } 509 return evt; 510 } 511 }; 512 function hydrateObj(obj, meta = {}) { 513 for (const [key, value] of Object.entries(meta)) { 514 try { 515 obj[key] = value; 516 } catch (_unused) { 517 Object.defineProperty(obj, key, { 518 configurable: true, 519 get() { 520 return value; 521 } 522 }); 523 } 524 } 525 return obj; 526 } 527 528 /** 529 * -------------------------------------------------------------------------- 530 *
vendor: 4,275 bytes, lines 530-671
530Bootstrap dom/manipulator.js 531 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 532 * -------------------------------------------------------------------------- 533 */ 534 535 function normalizeData(value) { 536 if (value === 'true') { 537 return true; 538 } 539 if (value === 'false') { 540 return false; 541 } 542 if (value === Number(value).toString()) { 543 return Number(value); 544 } 545 if (value === '' || value === 'null') { 546 return null; 547 } 548 if (typeof value !== 'string') { 549 return value; 550 } 551 try { 552 return JSON.parse(decodeURIComponent(value)); 553 } catch (_unused) { 554 return value; 555 } 556 } 557 function normalizeDataKey(key) { 558 return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`); 559 } 560 const Manipulator = { 561 setDataAttribute(element, key, value) { 562 element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value); 563 }, 564 removeDataAttribute(element, key) { 565 element.removeAttribute(`data-bs-${normalizeDataKey(key)}`); 566 }, 567 getDataAttributes(element) { 568 if (!element) { 569 return {}; 570 } 571 const attributes = {}; 572 const bsKeys = Object.keys(element.dataset).filter(key => key.startsWith('bs') && !key.startsWith('bsConfig')); 573 for (const key of bsKeys) { 574 let pureKey = key.replace(/^bs/, ''); 575 pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length); 576 attributes[pureKey] = normalizeData(element.dataset[key]); 577 } 578 return attributes; 579 }, 580 getDataAttribute(element, key) { 581 return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`)); 582 } 583 }; 584 585 /** 586 * -------------------------------------------------------------------------- 587 * Bootstrap util/config.js 588 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 589 * -------------------------------------------------------------------------- 590 */ 591 592 593 /** 594 * Class definition 595 */ 596 597 class Config { 598 // Getters 599 static get Default() { 600 return {}; 601 } 602 static get DefaultType() { 603 return {}; 604 } 605 static get NAME() { 606 throw new Error('You have to implement the static method "NAME", for each component!'); 607 } 608 _getConfig(config) { 609 config = this._mergeConfigObj(config); 610 config = this._configAfterMerge(config); 611 this._typeCheckConfig(config); 612 return config; 613 } 614 _configAfterMerge(config) { 615 return config; 616 } 617 _mergeConfigObj(config, element) { 618 const jsonConfig = isElement$1(element) ? Manipulator.getDataAttribute(element, 'config') : {}; // try to parse 619 620 return { 621 ...this.constructor.Default, 622 ...(typeof jsonConfig === 'object' ? jsonConfig : {}), 623 ...(isElement$1(element) ? Manipulator.getDataAttributes(element) : {}), 624 ...(typeof config === 'object' ? config : {}) 625 }; 626 } 627 _typeCheckConfig(config, configTypes = this.constructor.DefaultType) { 628 for (const [property, expectedTypes] of Object.entries(configTypes)) { 629 const value = config[property]; 630 const valueType = isElement$1(value) ? 'element' : toType(value); 631 if (!new RegExp(expectedTypes).test(valueType)) { 632 throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); 633 } 634 } 635 } 636 } 637 638 /** 639 * -------------------------------------------------------------------------- 640 * Bootstrap base-component.js 641 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 642 * -------------------------------------------------------------------------- 643 */ 644 645 646 /** 647 * Constants 648 */ 649 650 const VERSION = '5.3.3'; 651 652 /** 653 * Class definition 654 */ 655 656 class BaseComponent extends Config { 657 constructor(element, config) { 658 super(); 659 element = getElement(element); 660 if (!element) { 661 return; 662 } 663 this._element = element; 664 this._config = this._getConfig(config); 665 Data.set(this._element, this.constructor.DATA_KEY, this); 666 } 667 668 // Public 669 dispose() { 670 Data.remove(this._element, this.constructor.DATA_KEY); 671 EventHandler.off(this._element, this.constructor.EVENT_KEY);
672 for (const propertyName of Object.getOwnPropertyNames(this)) { 673 this[propertyName] = null; 674 } 675 }
vendor: 29,904 bytes, lines 675-1606
675 676 _queueCallback(callback, element, isAnimated = true) { 677 executeAfterTransition(callback, element, isAnimated); 678 } 679 _getConfig(config) { 680 config = this._mergeConfigObj(config, this._element); 681 config = this._configAfterMerge(config); 682 this._typeCheckConfig(config); 683 return config; 684 } 685 686 // Static 687 static getInstance(element) { 688 return Data.get(getElement(element), this.DATA_KEY); 689 } 690 static getOrCreateInstance(element, config = {}) { 691 return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null); 692 } 693 static get VERSION() { 694 return VERSION; 695 } 696 static get DATA_KEY() { 697 return `bs.${this.NAME}`; 698 } 699 static get EVENT_KEY() { 700 return `.${this.DATA_KEY}`; 701 } 702 static eventName(name) { 703 return `${name}${this.EVENT_KEY}`; 704 } 705 } 706 707 /** 708 * -------------------------------------------------------------------------- 709 * Bootstrap dom/selector-engine.js 710 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 711 * -------------------------------------------------------------------------- 712 */ 713 714 const getSelector = element => { 715 let selector = element.getAttribute('data-bs-target'); 716 if (!selector || selector === '#') { 717 let hrefAttribute = element.getAttribute('href'); 718 719 // The only valid content that could double as a selector are IDs or classes, 720 // so everything starting with `#` or `.`. If a "real" URL is used as the selector, 721 // `document.querySelector` will rightfully complain it is invalid. 722 // See https://github.com/twbs/bootstrap/issues/32273 723 if (!hrefAttribute || !hrefAttribute.includes('#') && !hrefAttribute.startsWith('.')) { 724 return null; 725 } 726 727 // Just in case some CMS puts out a full URL with the anchor appended 728 if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) { 729 hrefAttribute = `#${hrefAttribute.split('#')[1]}`; 730 } 731 selector = hrefAttribute && hrefAttribute !== '#' ? hrefAttribute.trim() : null; 732 } 733 return selector ? selector.split(',').map(sel => parseSelector(sel)).join(',') : null; 734 }; 735 const SelectorEngine = { 736 find(selector, element = document.documentElement) { 737 return [].concat(...Element.prototype.querySelectorAll.call(element, selector)); 738 }, 739 findOne(selector, element = document.documentElement) { 740 return Element.prototype.querySelector.call(element, selector); 741 }, 742 children(element, selector) { 743 return [].concat(...element.children).filter(child => child.matches(selector)); 744 }, 745 parents(element, selector) { 746 const parents = []; 747 let ancestor = element.parentNode.closest(selector); 748 while (ancestor) { 749 parents.push(ancestor); 750 ancestor = ancestor.parentNode.closest(selector); 751 } 752 return parents; 753 }, 754 prev(element, selector) { 755 let previous = element.previousElementSibling; 756 while (previous) { 757 if (previous.matches(selector)) { 758 return [previous]; 759 } 760 previous = previous.previousElementSibling; 761 } 762 return []; 763 }, 764 // TODO: this is now unused; remove later along with prev() 765 next(element, selector) { 766 let next = element.nextElementSibling; 767 while (next) { 768 if (next.matches(selector)) { 769 return [next]; 770 } 771 next = next.nextElementSibling; 772 } 773 return []; 774 }, 775 focusableChildren(element) { 776 const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(selector => `${selector}:not([tabindex^="-"])`).join(','); 777 return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el)); 778 }, 779 getSelectorFromElement(element) { 780 const selector = getSelector(element); 781 if (selector) { 782 return SelectorEngine.findOne(selector) ? selector : null; 783 } 784 return null; 785 }, 786 getElementFromSelector(element) { 787 const selector = getSelector(element); 788 return selector ? SelectorEngine.findOne(selector) : null; 789 }, 790 getMultipleElementsFromSelector(element) { 791 const selector = getSelector(element); 792 return selector ? SelectorEngine.find(selector) : []; 793 } 794 }; 795 796 /** 797 * -------------------------------------------------------------------------- 798 * Bootstrap util/component-functions.js 799 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 800 * -------------------------------------------------------------------------- 801 */ 802 803 const enableDismissTrigger = (component, method = 'hide') => { 804 const clickEvent = `click.dismiss${component.EVENT_KEY}`; 805 const name = component.NAME; 806 EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) { 807 if (['A', 'AREA'].includes(this.tagName)) { 808 event.preventDefault(); 809 } 810 if (isDisabled(this)) { 811 return; 812 } 813 const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`); 814 const instance = component.getOrCreateInstance(target); 815 816 // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method 817 instance[method](); 818 }); 819 }; 820 821 /** 822 * -------------------------------------------------------------------------- 823 * Bootstrap alert.js 824 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 825 * -------------------------------------------------------------------------- 826 */ 827 828 829 /** 830 * Constants 831 */ 832 833 const NAME$f = 'alert'; 834 const DATA_KEY$a = 'bs.alert'; 835 const EVENT_KEY$b = `.${DATA_KEY$a}`; 836 const EVENT_CLOSE = `close${EVENT_KEY$b}`; 837 const EVENT_CLOSED = `closed${EVENT_KEY$b}`; 838 const CLASS_NAME_FADE$5 = 'fade'; 839 const CLASS_NAME_SHOW$8 = 'show'; 840 841 /** 842 * Class definition 843 */ 844 845 class Alert extends BaseComponent { 846 // Getters 847 static get NAME() { 848 return NAME$f; 849 } 850 851 // Public 852 close() { 853 const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE); 854 if (closeEvent.defaultPrevented) { 855 return; 856 } 857 this._element.classList.remove(CLASS_NAME_SHOW$8); 858 const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5); 859 this._queueCallback(() => this._destroyElement(), this._element, isAnimated); 860 } 861 862 // Private 863 _destroyElement() { 864 this._element.remove(); 865 EventHandler.trigger(this._element, EVENT_CLOSED); 866 this.dispose(); 867 } 868 869 // Static 870 static jQueryInterface(config) { 871 return this.each(function () { 872 const data = Alert.getOrCreateInstance(this); 873 if (typeof config !== 'string') { 874 return; 875 } 876 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 877 throw new TypeError(`No method named "${config}"`); 878 } 879 data[config](this); 880 }); 881 } 882 } 883 884 /** 885 * Data API implementation 886 */ 887 888 enableDismissTrigger(Alert, 'close'); 889 890 /** 891 * jQuery 892 */ 893 894 defineJQueryPlugin(Alert); 895 896 /** 897 * -------------------------------------------------------------------------- 898 * Bootstrap button.js 899 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 900 * -------------------------------------------------------------------------- 901 */ 902 903 904 /** 905 * Constants 906 */ 907 908 const NAME$e = 'button'; 909 const DATA_KEY$9 = 'bs.button'; 910 const EVENT_KEY$a = `.${DATA_KEY$9}`; 911 const DATA_API_KEY$6 = '.data-api'; 912 const CLASS_NAME_ACTIVE$3 = 'active'; 913 const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]'; 914 const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`; 915 916 /** 917 * Class definition 918 */ 919 920 class Button extends BaseComponent { 921 // Getters 922 static get NAME() { 923 return NAME$e; 924 } 925 926 // Public 927 toggle() { 928 // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method 929 this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3)); 930 } 931 932 // Static 933 static jQueryInterface(config) { 934 return this.each(function () { 935 const data = Button.getOrCreateInstance(this); 936 if (config === 'toggle') { 937 data[config](); 938 } 939 }); 940 } 941 } 942 943 /** 944 * Data API implementation 945 */ 946 947 EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => { 948 event.preventDefault(); 949 const button = event.target.closest(SELECTOR_DATA_TOGGLE$5); 950 const data = Button.getOrCreateInstance(button); 951 data.toggle(); 952 }); 953 954 /** 955 * jQuery 956 */ 957 958 defineJQueryPlugin(Button); 959 960 /** 961 * -------------------------------------------------------------------------- 962 * Bootstrap util/swipe.js 963 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 964 * -------------------------------------------------------------------------- 965 */ 966 967 968 /** 969 * Constants 970 */ 971 972 const NAME$d = 'swipe'; 973 const EVENT_KEY$9 = '.bs.swipe'; 974 const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$9}`; 975 const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$9}`; 976 const EVENT_TOUCHEND = `touchend${EVENT_KEY$9}`; 977 const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$9}`; 978 const EVENT_POINTERUP = `pointerup${EVENT_KEY$9}`; 979 const POINTER_TYPE_TOUCH = 'touch'; 980 const POINTER_TYPE_PEN = 'pen'; 981 const CLASS_NAME_POINTER_EVENT = 'pointer-event'; 982 const SWIPE_THRESHOLD = 40; 983 const Default$c = { 984 endCallback: null, 985 leftCallback: null, 986 rightCallback: null 987 }; 988 const DefaultType$c = { 989 endCallback: '(function|null)', 990 leftCallback: '(function|null)', 991 rightCallback: '(function|null)' 992 }; 993 994 /** 995 * Class definition 996 */ 997 998 class Swipe extends Config { 999 constructor(element, config) { 1000 super(); 1001 this._element = element; 1002 if (!element || !Swipe.isSupported()) { 1003 return; 1004 } 1005 this._config = this._getConfig(config); 1006 this._deltaX = 0; 1007 this._supportPointerEvents = Boolean(window.PointerEvent); 1008 this._initEvents(); 1009 } 1010 1011 // Getters 1012 static get Default() { 1013 return Default$c; 1014 } 1015 static get DefaultType() { 1016 return DefaultType$c; 1017 } 1018 static get NAME() { 1019 return NAME$d; 1020 } 1021 1022 // Public 1023 dispose() { 1024 EventHandler.off(this._element, EVENT_KEY$9); 1025 } 1026 1027 // Private 1028 _start(event) { 1029 if (!this._supportPointerEvents) { 1030 this._deltaX = event.touches[0].clientX; 1031 return; 1032 } 1033 if (this._eventIsPointerPenTouch(event)) { 1034 this._deltaX = event.clientX; 1035 } 1036 } 1037 _end(event) { 1038 if (this._eventIsPointerPenTouch(event)) { 1039 this._deltaX = event.clientX - this._deltaX; 1040 } 1041 this._handleSwipe(); 1042 execute(this._config.endCallback); 1043 } 1044 _move(event) { 1045 this._deltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this._deltaX; 1046 } 1047 _handleSwipe() { 1048 const absDeltaX = Math.abs(this._deltaX); 1049 if (absDeltaX <= SWIPE_THRESHOLD) { 1050 return; 1051 } 1052 const direction = absDeltaX / this._deltaX; 1053 this._deltaX = 0; 1054 if (!direction) { 1055 return; 1056 } 1057 execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback); 1058 } 1059 _initEvents() { 1060 if (this._supportPointerEvents) { 1061 EventHandler.on(this._element, EVENT_POINTERDOWN, event => this._start(event)); 1062 EventHandler.on(this._element, EVENT_POINTERUP, event => this._end(event)); 1063 this._element.classList.add(CLASS_NAME_POINTER_EVENT); 1064 } else { 1065 EventHandler.on(this._element, EVENT_TOUCHSTART, event => this._start(event)); 1066 EventHandler.on(this._element, EVENT_TOUCHMOVE, event => this._move(event)); 1067 EventHandler.on(this._element, EVENT_TOUCHEND, event => this._end(event)); 1068 } 1069 } 1070 _eventIsPointerPenTouch(event) { 1071 return this._supportPointerEvents && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH); 1072 } 1073 1074 // Static 1075 static isSupported() { 1076 return 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0; 1077 } 1078 } 1079 1080 /** 1081 * -------------------------------------------------------------------------- 1082 * Bootstrap carousel.js 1083 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 1084 * -------------------------------------------------------------------------- 1085 */ 1086 1087 1088 /** 1089 * Constants 1090 */ 1091 1092 const NAME$c = 'carousel'; 1093 const DATA_KEY$8 = 'bs.carousel'; 1094 const EVENT_KEY$8 = `.${DATA_KEY$8}`; 1095 const DATA_API_KEY$5 = '.data-api'; 1096 const ARROW_LEFT_KEY$1 = 'ArrowLeft'; 1097 const ARROW_RIGHT_KEY$1 = 'ArrowRight'; 1098 const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch 1099 1100 const ORDER_NEXT = 'next'; 1101 const ORDER_PREV = 'prev'; 1102 const DIRECTION_LEFT = 'left'; 1103 const DIRECTION_RIGHT = 'right'; 1104 const EVENT_SLIDE = `slide${EVENT_KEY$8}`; 1105 const EVENT_SLID = `slid${EVENT_KEY$8}`; 1106 const EVENT_KEYDOWN$1 = `keydown${EVENT_KEY$8}`; 1107 const EVENT_MOUSEENTER$1 = `mouseenter${EVENT_KEY$8}`; 1108 const EVENT_MOUSELEAVE$1 = `mouseleave${EVENT_KEY$8}`; 1109 const EVENT_DRAG_START = `dragstart${EVENT_KEY$8}`; 1110 const EVENT_LOAD_DATA_API$3 = `load${EVENT_KEY$8}${DATA_API_KEY$5}`; 1111 const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`; 1112 const CLASS_NAME_CAROUSEL = 'carousel'; 1113 const CLASS_NAME_ACTIVE$2 = 'active'; 1114 const CLASS_NAME_SLIDE = 'slide'; 1115 const CLASS_NAME_END = 'carousel-item-end'; 1116 const CLASS_NAME_START = 'carousel-item-start'; 1117 const CLASS_NAME_NEXT = 'carousel-item-next'; 1118 const CLASS_NAME_PREV = 'carousel-item-prev'; 1119 const SELECTOR_ACTIVE = '.active'; 1120 const SELECTOR_ITEM = '.carousel-item'; 1121 const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_ITEM; 1122 const SELECTOR_ITEM_IMG = '.carousel-item img'; 1123 const SELECTOR_INDICATORS = '.carousel-indicators'; 1124 const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]'; 1125 const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]'; 1126 const KEY_TO_DIRECTION = { 1127 [ARROW_LEFT_KEY$1]: DIRECTION_RIGHT, 1128 [ARROW_RIGHT_KEY$1]: DIRECTION_LEFT 1129 }; 1130 const Default$b = { 1131 interval: 5000, 1132 keyboard: true, 1133 pause: 'hover', 1134 ride: false, 1135 touch: true, 1136 wrap: true 1137 }; 1138 const DefaultType$b = { 1139 interval: '(number|boolean)', 1140 // TODO:v6 remove boolean support 1141 keyboard: 'boolean', 1142 pause: '(string|boolean)', 1143 ride: '(boolean|string)', 1144 touch: 'boolean', 1145 wrap: 'boolean' 1146 }; 1147 1148 /** 1149 * Class definition 1150 */ 1151 1152 class Carousel extends BaseComponent { 1153 constructor(element, config) { 1154 super(element, config); 1155 this._interval = null; 1156 this._activeElement = null; 1157 this._isSliding = false; 1158 this.touchTimeout = null; 1159 this._swipeHelper = null; 1160 this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element); 1161 this._addEventListeners(); 1162 if (this._config.ride === CLASS_NAME_CAROUSEL) { 1163 this.cycle(); 1164 } 1165 } 1166 1167 // Getters 1168 static get Default() { 1169 return Default$b; 1170 } 1171 static get DefaultType() { 1172 return DefaultType$b; 1173 } 1174 static get NAME() { 1175 return NAME$c; 1176 } 1177 1178 // Public 1179 next() { 1180 this._slide(ORDER_NEXT); 1181 } 1182 nextWhenVisible() { 1183 // FIXME TODO use `document.visibilityState` 1184 // Don't call next when the page isn't visible 1185 // or the carousel or its parent isn't visible 1186 if (!document.hidden && isVisible(this._element)) { 1187 this.next(); 1188 } 1189 } 1190 prev() { 1191 this._slide(ORDER_PREV); 1192 } 1193 pause() { 1194 if (this._isSliding) { 1195 triggerTransitionEnd(this._element); 1196 } 1197 this._clearInterval(); 1198 } 1199 cycle() { 1200 this._clearInterval(); 1201 this._updateInterval(); 1202 this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval); 1203 } 1204 _maybeEnableCycle() { 1205 if (!this._config.ride) { 1206 return; 1207 } 1208 if (this._isSliding) { 1209 EventHandler.one(this._element, EVENT_SLID, () => this.cycle()); 1210 return; 1211 } 1212 this.cycle(); 1213 } 1214 to(index) { 1215 const items = this._getItems(); 1216 if (index > items.length - 1 || index < 0) { 1217 return; 1218 } 1219 if (this._isSliding) { 1220 EventHandler.one(this._element, EVENT_SLID, () => this.to(index)); 1221 return; 1222 } 1223 const activeIndex = this._getItemIndex(this._getActive()); 1224 if (activeIndex === index) { 1225 return; 1226 } 1227 const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV; 1228 this._slide(order, items[index]); 1229 } 1230 dispose() { 1231 if (this._swipeHelper) { 1232 this._swipeHelper.dispose(); 1233 } 1234 super.dispose(); 1235 } 1236 1237 // Private 1238 _configAfterMerge(config) { 1239 config.defaultInterval = config.interval; 1240 return config; 1241 } 1242 _addEventListeners() { 1243 if (this._config.keyboard) { 1244 EventHandler.on(this._element, EVENT_KEYDOWN$1, event => this._keydown(event)); 1245 } 1246 if (this._config.pause === 'hover') { 1247 EventHandler.on(this._element, EVENT_MOUSEENTER$1, () => this.pause()); 1248 EventHandler.on(this._element, EVENT_MOUSELEAVE$1, () => this._maybeEnableCycle()); 1249 } 1250 if (this._config.touch && Swipe.isSupported()) { 1251 this._addTouchEventListeners(); 1252 } 1253 } 1254 _addTouchEventListeners() { 1255 for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) { 1256 EventHandler.on(img, EVENT_DRAG_START, event => event.preventDefault()); 1257 } 1258 const endCallBack = () => { 1259 if (this._config.pause !== 'hover') { 1260 return; 1261 } 1262 1263 // If it's a touch-enabled device, mouseenter/leave are fired as 1264 // part of the mouse compatibility events on first tap - the carousel 1265 // would stop cycling until user tapped out of it; 1266 // here, we listen for touchend, explicitly pause the carousel 1267 // (as if it's the second time we tap on it, mouseenter compat event 1268 // is NOT fired) and after a timeout (to allow for mouse compatibility 1269 // events to fire) we explicitly restart cycling 1270 1271 this.pause(); 1272 if (this.touchTimeout) { 1273 clearTimeout(this.touchTimeout); 1274 } 1275 this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval); 1276 }; 1277 const swipeConfig = { 1278 leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)), 1279 rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)), 1280 endCallback: endCallBack 1281 }; 1282 this._swipeHelper = new Swipe(this._element, swipeConfig); 1283 } 1284 _keydown(event) { 1285 if (/input|textarea/i.test(event.target.tagName)) { 1286 return; 1287 } 1288 const direction = KEY_TO_DIRECTION[event.key]; 1289 if (direction) { 1290 event.preventDefault(); 1291 this._slide(this._directionToOrder(direction)); 1292 } 1293 } 1294 _getItemIndex(element) { 1295 return this._getItems().indexOf(element); 1296 } 1297 _setActiveIndicatorElement(index) { 1298 if (!this._indicatorsElement) { 1299 return; 1300 } 1301 const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement); 1302 activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2); 1303 activeIndicator.removeAttribute('aria-current'); 1304 const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement); 1305 if (newActiveIndicator) { 1306 newActiveIndicator.classList.add(CLASS_NAME_ACTIVE$2); 1307 newActiveIndicator.setAttribute('aria-current', 'true'); 1308 } 1309 } 1310 _updateInterval() { 1311 const element = this._activeElement || this._getActive(); 1312 if (!element) { 1313 return; 1314 } 1315 const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10); 1316 this._config.interval = elementInterval || this._config.defaultInterval; 1317 } 1318 _slide(order, element = null) { 1319 if (this._isSliding) { 1320 return; 1321 } 1322 const activeElement = this._getActive(); 1323 const isNext = order === ORDER_NEXT; 1324 const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap); 1325 if (nextElement === activeElement) { 1326 return; 1327 } 1328 const nextElementIndex = this._getItemIndex(nextElement); 1329 const triggerEvent = eventName => { 1330 return EventHandler.trigger(this._element, eventName, { 1331 relatedTarget: nextElement, 1332 direction: this._orderToDirection(order), 1333 from: this._getItemIndex(activeElement), 1334 to: nextElementIndex 1335 }); 1336 }; 1337 const slideEvent = triggerEvent(EVENT_SLIDE); 1338 if (slideEvent.defaultPrevented) { 1339 return; 1340 } 1341 if (!activeElement || !nextElement) { 1342 // Some weirdness is happening, so we bail 1343 // TODO: change tests that use empty divs to avoid this check 1344 return; 1345 } 1346 const isCycling = Boolean(this._interval); 1347 this.pause(); 1348 this._isSliding = true; 1349 this._setActiveIndicatorElement(nextElementIndex); 1350 this._activeElement = nextElement; 1351 const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END; 1352 const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV; 1353 nextElement.classList.add(orderClassName); 1354 reflow(nextElement); 1355 activeElement.classList.add(directionalClassName); 1356 nextElement.classList.add(directionalClassName); 1357 const completeCallBack = () => { 1358 nextElement.classList.remove(directionalClassName, orderClassName); 1359 nextElement.classList.add(CLASS_NAME_ACTIVE$2); 1360 activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName); 1361 this._isSliding = false; 1362 triggerEvent(EVENT_SLID); 1363 }; 1364 this._queueCallback(completeCallBack, activeElement, this._isAnimated()); 1365 if (isCycling) { 1366 this.cycle(); 1367 } 1368 } 1369 _isAnimated() { 1370 return this._element.classList.contains(CLASS_NAME_SLIDE); 1371 } 1372 _getActive() { 1373 return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element); 1374 } 1375 _getItems() { 1376 return SelectorEngine.find(SELECTOR_ITEM, this._element); 1377 } 1378 _clearInterval() { 1379 if (this._interval) { 1380 clearInterval(this._interval); 1381 this._interval = null; 1382 } 1383 } 1384 _directionToOrder(direction) { 1385 if (isRTL()) { 1386 return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT; 1387 } 1388 return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV; 1389 } 1390 _orderToDirection(order) { 1391 if (isRTL()) { 1392 return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT; 1393 } 1394 return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT; 1395 } 1396 1397 // Static 1398 static jQueryInterface(config) { 1399 return this.each(function () { 1400 const data = Carousel.getOrCreateInstance(this, config); 1401 if (typeof config === 'number') { 1402 data.to(config); 1403 return; 1404 } 1405 if (typeof config === 'string') { 1406 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 1407 throw new TypeError(`No method named "${config}"`); 1408 } 1409 data[config](); 1410 } 1411 }); 1412 } 1413 } 1414 1415 /** 1416 * Data API implementation 1417 */ 1418 1419 EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, function (event) { 1420 const target = SelectorEngine.getElementFromSelector(this); 1421 if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) { 1422 return; 1423 } 1424 event.preventDefault(); 1425 const carousel = Carousel.getOrCreateInstance(target); 1426 const slideIndex = this.getAttribute('data-bs-slide-to'); 1427 if (slideIndex) { 1428 carousel.to(slideIndex); 1429 carousel._maybeEnableCycle(); 1430 return; 1431 } 1432 if (Manipulator.getDataAttribute(this, 'slide') === 'next') { 1433 carousel.next(); 1434 carousel._maybeEnableCycle(); 1435 return; 1436 } 1437 carousel.prev(); 1438 carousel._maybeEnableCycle(); 1439 }); 1440 EventHandler.on(window, EVENT_LOAD_DATA_API$3, () => { 1441 const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE); 1442 for (const carousel of carousels) { 1443 Carousel.getOrCreateInstance(carousel); 1444 } 1445 }); 1446 1447 /** 1448 * jQuery 1449 */ 1450 1451 defineJQueryPlugin(Carousel); 1452 1453 /** 1454 * -------------------------------------------------------------------------- 1455 * Bootstrap collapse.js 1456 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 1457 * -------------------------------------------------------------------------- 1458 */ 1459 1460 1461 /** 1462 * Constants 1463 */ 1464 1465 const NAME$b = 'collapse'; 1466 const DATA_KEY$7 = 'bs.collapse'; 1467 const EVENT_KEY$7 = `.${DATA_KEY$7}`; 1468 const DATA_API_KEY$4 = '.data-api'; 1469 const EVENT_SHOW$6 = `show${EVENT_KEY$7}`; 1470 const EVENT_SHOWN$6 = `shown${EVENT_KEY$7}`; 1471 const EVENT_HIDE$6 = `hide${EVENT_KEY$7}`; 1472 const EVENT_HIDDEN$6 = `hidden${EVENT_KEY$7}`; 1473 const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`; 1474 const CLASS_NAME_SHOW$7 = 'show'; 1475 const CLASS_NAME_COLLAPSE = 'collapse'; 1476 const CLASS_NAME_COLLAPSING = 'collapsing'; 1477 const CLASS_NAME_COLLAPSED = 'collapsed'; 1478 const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`; 1479 const CLASS_NAME_HORIZONTAL = 'collapse-horizontal'; 1480 const WIDTH = 'width'; 1481 const HEIGHT = 'height'; 1482 const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing'; 1483 const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]'; 1484 const Default$a = { 1485 parent: null, 1486 toggle: true 1487 }; 1488 const DefaultType$a = { 1489 parent: '(null|element)', 1490 toggle: 'boolean' 1491 }; 1492 1493 /** 1494 * Class definition 1495 */ 1496 1497 class Collapse extends BaseComponent { 1498 constructor(element, config) { 1499 super(element, config); 1500 this._isTransitioning = false; 1501 this._triggerArray = []; 1502 const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4); 1503 for (const elem of toggleList) { 1504 const selector = SelectorEngine.getSelectorFromElement(elem); 1505 const filterElement = SelectorEngine.find(selector).filter(foundElement => foundElement === this._element); 1506 if (selector !== null && filterElement.length) { 1507 this._triggerArray.push(elem); 1508 } 1509 } 1510 this._initializeChildren(); 1511 if (!this._config.parent) { 1512 this._addAriaAndCollapsedClass(this._triggerArray, this._isShown()); 1513 } 1514 if (this._config.toggle) { 1515 this.toggle(); 1516 } 1517 } 1518 1519 // Getters 1520 static get Default() { 1521 return Default$a; 1522 } 1523 static get DefaultType() { 1524 return DefaultType$a; 1525 } 1526 static get NAME() { 1527 return NAME$b; 1528 } 1529 1530 // Public 1531 toggle() { 1532 if (this._isShown()) { 1533 this.hide(); 1534 } else { 1535 this.show(); 1536 } 1537 } 1538 show() { 1539 if (this._isTransitioning || this._isShown()) { 1540 return; 1541 } 1542 let activeChildren = []; 1543 1544 // find active children 1545 if (this._config.parent) { 1546 activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES).filter(element => element !== this._element).map(element => Collapse.getOrCreateInstance(element, { 1547 toggle: false 1548 })); 1549 } 1550 if (activeChildren.length && activeChildren[0]._isTransitioning) { 1551 return; 1552 } 1553 const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$6); 1554 if (startEvent.defaultPrevented) { 1555 return; 1556 } 1557 for (const activeInstance of activeChildren) { 1558 activeInstance.hide(); 1559 } 1560 const dimension = this._getDimension(); 1561 this._element.classList.remove(CLASS_NAME_COLLAPSE); 1562 this._element.classList.add(CLASS_NAME_COLLAPSING); 1563 this._element.style[dimension] = 0; 1564 this._addAriaAndCollapsedClass(this._triggerArray, true); 1565 this._isTransitioning = true; 1566 const complete = () => { 1567 this._isTransitioning = false; 1568 this._element.classList.remove(CLASS_NAME_COLLAPSING); 1569 this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7); 1570 this._element.style[dimension] = ''; 1571 EventHandler.trigger(this._element, EVENT_SHOWN$6); 1572 }; 1573 const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1); 1574 const scrollSize = `scroll${capitalizedDimension}`; 1575 this._queueCallback(complete, this._element, true); 1576 this._element.style[dimension] = `${this._element[scrollSize]}px`; 1577 } 1578 hide() { 1579 if (this._isTransitioning || !this._isShown()) { 1580 return; 1581 } 1582 const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6); 1583 if (startEvent.defaultPrevented) { 1584 return; 1585 } 1586 const dimension = this._getDimension(); 1587 this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`; 1588 reflow(this._element); 1589 this._element.classList.add(CLASS_NAME_COLLAPSING); 1590 this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7); 1591 for (const trigger of this._triggerArray) { 1592 const element = SelectorEngine.getElementFromSelector(trigger); 1593 if (element && !this._isShown(element)) { 1594 this._addAriaAndCollapsedClass([trigger], false); 1595 } 1596 } 1597 this._isTransitioning = true; 1598 const complete = () => { 1599 this._isTransitioning = false; 1600 this._element.classList.remove(CLASS_NAME_COLLAPSING); 1601 this._element.classList.add(CLASS_NAME_COLLAPSE); 1602 EventHandler.trigger(this._element, EVENT_HIDDEN$6); 1603 }; 1604 this._element.style[dimension] = ''; 1605 this._queueCallback(complete, this._element, true); 1606 }
vendor: 2,007 bytes, lines 1607-1669
1607 _isShown(element = this._element) { 1608 return element.classList.contains(CLASS_NAME_SHOW$7); 1609 } 1610 1611 // Private 1612 _configAfterMerge(config) { 1613 config.toggle = Boolean(config.toggle); // Coerce string values 1614 config.parent = getElement(config.parent); 1615 return config; 1616 } 1617 _getDimension() { 1618 return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT; 1619 } 1620 _initializeChildren() { 1621 if (!this._config.parent) { 1622 return; 1623 } 1624 const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE$4); 1625 for (const element of children) { 1626 const selected = SelectorEngine.getElementFromSelector(element); 1627 if (selected) { 1628 this._addAriaAndCollapsedClass([element], this._isShown(selected)); 1629 } 1630 } 1631 } 1632 _getFirstLevelChildren(selector) { 1633 const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent); 1634 // remove children if greater depth 1635 return SelectorEngine.find(selector, this._config.parent).filter(element => !children.includes(element)); 1636 } 1637 _addAriaAndCollapsedClass(triggerArray, isOpen) { 1638 if (!triggerArray.length) { 1639 return; 1640 } 1641 for (const element of triggerArray) { 1642 element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen); 1643 element.setAttribute('aria-expanded', isOpen); 1644 } 1645 } 1646 1647 // Static 1648 static jQueryInterface(config) { 1649 const _config = {}; 1650 if (typeof config === 'string' && /show|hide/.test(config)) { 1651 _config.toggle = false; 1652 } 1653 return this.each(function () { 1654 const data = Collapse.getOrCreateInstance(this, _config); 1655 if (typeof config === 'string') { 1656 if (typeof data[config] === 'undefined') { 1657 throw new TypeError(`No method named "${config}"`); 1658 } 1659 data[config](); 1660 } 1661 }); 1662 } 1663 } 1664 1665 /** 1666 * Data API implementation 1667 */ 1668 1669 EventHandler.on(document, EVENT_CLICK_DATA_API$4
vendor: 17,041 bytes, lines 1669-2214
1669, SELECTOR_DATA_TOGGLE$4, function (event) { 1670 // preventDefault only for <a> elements (which change the URL) not inside the collapsible element 1671 if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') { 1672 event.preventDefault(); 1673 } 1674 for (const element of SelectorEngine.getMultipleElementsFromSelector(this)) { 1675 Collapse.getOrCreateInstance(element, { 1676 toggle: false 1677 }).toggle(); 1678 } 1679 }); 1680 1681 /** 1682 * jQuery 1683 */ 1684 1685 defineJQueryPlugin(Collapse); 1686 1687 var top = 'top'; 1688 var bottom = 'bottom'; 1689 var right = 'right'; 1690 var left = 'left'; 1691 var auto = 'auto'; 1692 var basePlacements = [top, bottom, right, left]; 1693 var start = 'start'; 1694 var end = 'end'; 1695 var clippingParents = 'clippingParents'; 1696 var viewport = 'viewport'; 1697 var popper = 'popper'; 1698 var reference = 'reference'; 1699 var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) { 1700 return acc.concat([placement + "-" + start, placement + "-" + end]); 1701 }, []); 1702 var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) { 1703 return acc.concat([placement, placement + "-" + start, placement + "-" + end]); 1704 }, []); // modifiers that need to read the DOM 1705 1706 var beforeRead = 'beforeRead'; 1707 var read = 'read'; 1708 var afterRead = 'afterRead'; // pure-logic modifiers 1709 1710 var beforeMain = 'beforeMain'; 1711 var main = 'main'; 1712 var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state) 1713 1714 var beforeWrite = 'beforeWrite'; 1715 var write = 'write'; 1716 var afterWrite = 'afterWrite'; 1717 var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite]; 1718 1719 function getNodeName(element) { 1720 return element ? (element.nodeName || '').toLowerCase() : null; 1721 } 1722 1723 function getWindow(node) { 1724 if (node == null) { 1725 return window; 1726 } 1727 1728 if (node.toString() !== '[object Window]') { 1729 var ownerDocument = node.ownerDocument; 1730 return ownerDocument ? ownerDocument.defaultView || window : window; 1731 } 1732 1733 return node; 1734 } 1735 1736 function isElement(node) { 1737 var OwnElement = getWindow(node).Element; 1738 return node instanceof OwnElement || node instanceof Element; 1739 } 1740 1741 function isHTMLElement(node) { 1742 var OwnElement = getWindow(node).HTMLElement; 1743 return node instanceof OwnElement || node instanceof HTMLElement; 1744 } 1745 1746 function isShadowRoot(node) { 1747 // IE 11 has no ShadowRoot 1748 if (typeof ShadowRoot === 'undefined') { 1749 return false; 1750 } 1751 1752 var OwnElement = getWindow(node).ShadowRoot; 1753 return node instanceof OwnElement || node instanceof ShadowRoot; 1754 } 1755 1756 // and applies them to the HTMLElements such as popper and arrow 1757 1758 function applyStyles(_ref) { 1759 var state = _ref.state; 1760 Object.keys(state.elements).forEach(function (name) { 1761 var style = state.styles[name] || {}; 1762 var attributes = state.attributes[name] || {}; 1763 var element = state.elements[name]; // arrow is optional + virtual elements 1764 1765 if (!isHTMLElement(element) || !getNodeName(element)) { 1766 return; 1767 } // Flow doesn't support to extend this property, but it's the most 1768 // effective way to apply styles to an HTMLElement 1769 // $FlowFixMe[cannot-write] 1770 1771 1772 Object.assign(element.style, style); 1773 Object.keys(attributes).forEach(function (name) { 1774 var value = attributes[name]; 1775 1776 if (value === false) { 1777 element.removeAttribute(name); 1778 } else { 1779 element.setAttribute(name, value === true ? '' : value); 1780 } 1781 }); 1782 }); 1783 } 1784 1785 function effect$2(_ref2) { 1786 var state = _ref2.state; 1787 var initialStyles = { 1788 popper: { 1789 position: state.options.strategy, 1790 left: '0', 1791 top: '0', 1792 margin: '0' 1793 }, 1794 arrow: { 1795 position: 'absolute' 1796 }, 1797 reference: {} 1798 }; 1799 Object.assign(state.elements.popper.style, initialStyles.popper); 1800 state.styles = initialStyles; 1801 1802 if (state.elements.arrow) { 1803 Object.assign(state.elements.arrow.style, initialStyles.arrow); 1804 } 1805 1806 return function () { 1807 Object.keys(state.elements).forEach(function (name) { 1808 var element = state.elements[name]; 1809 var attributes = state.attributes[name] || {}; 1810 var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them 1811 1812 var style = styleProperties.reduce(function (style, property) { 1813 style[property] = ''; 1814 return style; 1815 }, {}); // arrow is optional + virtual elements 1816 1817 if (!isHTMLElement(element) || !getNodeName(element)) { 1818 return; 1819 } 1820 1821 Object.assign(element.style, style); 1822 Object.keys(attributes).forEach(function (attribute) { 1823 element.removeAttribute(attribute); 1824 }); 1825 }); 1826 }; 1827 } // eslint-disable-next-line import/no-unused-modules 1828 1829 1830 const applyStyles$1 = { 1831 name: 'applyStyles', 1832 enabled: true, 1833 phase: 'write', 1834 fn: applyStyles, 1835 effect: effect$2, 1836 requires: ['computeStyles'] 1837 }; 1838 1839 function getBasePlacement(placement) { 1840 return placement.split('-')[0]; 1841 } 1842 1843 var max = Math.max; 1844 var min = Math.min; 1845 var round = Math.round; 1846 1847 function getUAString() { 1848 var uaData = navigator.userAgentData; 1849 1850 if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) { 1851 return uaData.brands.map(function (item) { 1852 return item.brand + "/" + item.version; 1853 }).join(' '); 1854 } 1855 1856 return navigator.userAgent; 1857 } 1858 1859 function isLayoutViewport() { 1860 return !/^((?!chrome|android).)*safari/i.test(getUAString()); 1861 } 1862 1863 function getBoundingClientRect(element, includeScale, isFixedStrategy) { 1864 if (includeScale === void 0) { 1865 includeScale = false; 1866 } 1867 1868 if (isFixedStrategy === void 0) { 1869 isFixedStrategy = false; 1870 } 1871 1872 var clientRect = element.getBoundingClientRect(); 1873 var scaleX = 1; 1874 var scaleY = 1; 1875 1876 if (includeScale && isHTMLElement(element)) { 1877 scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1; 1878 scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1; 1879 } 1880 1881 var _ref = isElement(element) ? getWindow(element) : window, 1882 visualViewport = _ref.visualViewport; 1883 1884 var addVisualOffsets = !isLayoutViewport() && isFixedStrategy; 1885 var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX; 1886 var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY; 1887 var width = clientRect.width / scaleX; 1888 var height = clientRect.height / scaleY; 1889 return { 1890 width: width, 1891 height: height, 1892 top: y, 1893 right: x + width, 1894 bottom: y + height, 1895 left: x, 1896 x: x, 1897 y: y 1898 }; 1899 } 1900 1901 // means it doesn't take into account transforms. 1902 1903 function getLayoutRect(element) { 1904 var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed. 1905 // Fixes https://github.com/popperjs/popper-core/issues/1223 1906 1907 var width = element.offsetWidth; 1908 var height = element.offsetHeight; 1909 1910 if (Math.abs(clientRect.width - width) <= 1) { 1911 width = clientRect.width; 1912 } 1913 1914 if (Math.abs(clientRect.height - height) <= 1) { 1915 height = clientRect.height; 1916 } 1917 1918 return { 1919 x: element.offsetLeft, 1920 y: element.offsetTop, 1921 width: width, 1922 height: height 1923 }; 1924 } 1925 1926 function contains(parent, child) { 1927 var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method 1928 1929 if (parent.contains(child)) { 1930 return true; 1931 } // then fallback to custom implementation with Shadow DOM support 1932 else if (rootNode && isShadowRoot(rootNode)) { 1933 var next = child; 1934 1935 do { 1936 if (next && parent.isSameNode(next)) { 1937 return true; 1938 } // $FlowFixMe[prop-missing]: need a better way to handle this... 1939 1940 1941 next = next.parentNode || next.host; 1942 } while (next); 1943 } // Give up, the result is false 1944 1945 1946 return false; 1947 } 1948 1949 function getComputedStyle$1(element) { 1950 return getWindow(element).getComputedStyle(element); 1951 } 1952 1953 function isTableElement(element) { 1954 return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0; 1955 } 1956 1957 function getDocumentElement(element) { 1958 // $FlowFixMe[incompatible-return]: assume body is always available 1959 return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing] 1960 element.document) || window.document).documentElement; 1961 } 1962 1963 function getParentNode(element) { 1964 if (getNodeName(element) === 'html') { 1965 return element; 1966 } 1967 1968 return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle 1969 // $FlowFixMe[incompatible-return] 1970 // $FlowFixMe[prop-missing] 1971 element.assignedSlot || // step into the shadow DOM of the parent of a slotted node 1972 element.parentNode || ( // DOM Element detected 1973 isShadowRoot(element) ? element.host : null) || // ShadowRoot detected 1974 // $FlowFixMe[incompatible-call]: HTMLElement is a Node 1975 getDocumentElement(element) // fallback 1976 1977 ); 1978 } 1979 1980 function getTrueOffsetParent(element) { 1981 if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837 1982 getComputedStyle$1(element).position === 'fixed') { 1983 return null; 1984 } 1985 1986 return element.offsetParent; 1987 } // `.offsetParent` reports `null` for fixed elements, while absolute elements 1988 // return the containing block 1989 1990 1991 function getContainingBlock(element) { 1992 var isFirefox = /firefox/i.test(getUAString()); 1993 var isIE = /Trident/i.test(getUAString()); 1994 1995 if (isIE && isHTMLElement(element)) { 1996 // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport 1997 var elementCss = getComputedStyle$1(element); 1998 1999 if (elementCss.position === 'fixed') { 2000 return null; 2001 } 2002 } 2003 2004 var currentNode = getParentNode(element); 2005 2006 if (isShadowRoot(currentNode)) { 2007 currentNode = currentNode.host; 2008 } 2009 2010 while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) { 2011 var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that 2012 // create a containing block. 2013 // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block 2014 2015 if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') { 2016 return currentNode; 2017 } else { 2018 currentNode = currentNode.parentNode; 2019 } 2020 } 2021 2022 return null; 2023 } // Gets the closest ancestor positioned element. Handles some edge cases, 2024 // such as table ancestors and cross browser bugs. 2025 2026 2027 function getOffsetParent(element) { 2028 var window = getWindow(element); 2029 var offsetParent = getTrueOffsetParent(element); 2030 2031 while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') { 2032 offsetParent = getTrueOffsetParent(offsetParent); 2033 } 2034 2035 if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static')) { 2036 return window; 2037 } 2038 2039 return offsetParent || getContainingBlock(element) || window; 2040 } 2041 2042 function getMainAxisFromPlacement(placement) { 2043 return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y'; 2044 } 2045 2046 function within(min$1, value, max$1) { 2047 return max(min$1, min(value, max$1)); 2048 } 2049 function withinMaxClamp(min, value, max) { 2050 var v = within(min, value, max); 2051 return v > max ? max : v; 2052 } 2053 2054 function getFreshSideObject() { 2055 return { 2056 top: 0, 2057 right: 0, 2058 bottom: 0, 2059 left: 0 2060 }; 2061 } 2062 2063 function mergePaddingObject(paddingObject) { 2064 return Object.assign({}, getFreshSideObject(), paddingObject); 2065 } 2066 2067 function expandToHashMap(value, keys) { 2068 return keys.reduce(function (hashMap, key) { 2069 hashMap[key] = value; 2070 return hashMap; 2071 }, {}); 2072 } 2073 2074 var toPaddingObject = function toPaddingObject(padding, state) { 2075 padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, { 2076 placement: state.placement 2077 })) : padding; 2078 return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); 2079 }; 2080 2081 function arrow(_ref) { 2082 var _state$modifiersData$; 2083 2084 var state = _ref.state, 2085 name = _ref.name, 2086 options = _ref.options; 2087 var arrowElement = state.elements.arrow; 2088 var popperOffsets = state.modifiersData.popperOffsets; 2089 var basePlacement = getBasePlacement(state.placement); 2090 var axis = getMainAxisFromPlacement(basePlacement); 2091 var isVertical = [left, right].indexOf(basePlacement) >= 0; 2092 var len = isVertical ? 'height' : 'width'; 2093 2094 if (!arrowElement || !popperOffsets) { 2095 return; 2096 } 2097 2098 var paddingObject = toPaddingObject(options.padding, state); 2099 var arrowRect = getLayoutRect(arrowElement); 2100 var minProp = axis === 'y' ? top : left; 2101 var maxProp = axis === 'y' ? bottom : right; 2102 var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len]; 2103 var startDiff = popperOffsets[axis] - state.rects.reference[axis]; 2104 var arrowOffsetParent = getOffsetParent(arrowElement); 2105 var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0; 2106 var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is 2107 // outside of the popper bounds 2108 2109 var min = paddingObject[minProp]; 2110 var max = clientSize - arrowRect[len] - paddingObject[maxProp]; 2111 var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference; 2112 var offset = within(min, center, max); // Prevents breaking syntax highlighting... 2113 2114 var axisProp = axis; 2115 state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$); 2116 } 2117 2118 function effect$1(_ref2) { 2119 var state = _ref2.state, 2120 options = _ref2.options; 2121 var _options$element = options.element, 2122 arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element; 2123 2124 if (arrowElement == null) { 2125 return; 2126 } // CSS selector 2127 2128 2129 if (typeof arrowElement === 'string') { 2130 arrowElement = state.elements.popper.querySelector(arrowElement); 2131 2132 if (!arrowElement) { 2133 return; 2134 } 2135 } 2136 2137 if (!contains(state.elements.popper, arrowElement)) { 2138 return; 2139 } 2140 2141 state.elements.arrow = arrowElement; 2142 } // eslint-disable-next-line import/no-unused-modules 2143 2144 2145 const arrow$1 = { 2146 name: 'arrow', 2147 enabled: true, 2148 phase: 'main', 2149 fn: arrow, 2150 effect: effect$1, 2151 requires: ['popperOffsets'], 2152 requiresIfExists: ['preventOverflow'] 2153 }; 2154 2155 function getVariation(placement) { 2156 return placement.split('-')[1]; 2157 } 2158 2159 var unsetSides = { 2160 top: 'auto', 2161 right: 'auto', 2162 bottom: 'auto', 2163 left: 'auto' 2164 }; // Round the offsets to the nearest suitable subpixel based on the DPR. 2165 // Zooming can change the DPR, but it seems to report a value that will 2166 // cleanly divide the values into the appropriate subpixels. 2167 2168 function roundOffsetsByDPR(_ref, win) { 2169 var x = _ref.x, 2170 y = _ref.y; 2171 var dpr = win.devicePixelRatio || 1; 2172 return { 2173 x: round(x * dpr) / dpr || 0, 2174 y: round(y * dpr) / dpr || 0 2175 }; 2176 } 2177 2178 function mapToStyles(_ref2) { 2179 var _Object$assign2; 2180 2181 var popper = _ref2.popper, 2182 popperRect = _ref2.popperRect, 2183 placement = _ref2.placement, 2184 variation = _ref2.variation, 2185 offsets = _ref2.offsets, 2186 position = _ref2.position, 2187 gpuAcceleration = _ref2.gpuAcceleration, 2188 adaptive = _ref2.adaptive, 2189 roundOffsets = _ref2.roundOffsets, 2190 isFixed = _ref2.isFixed; 2191 var _offsets$x = offsets.x, 2192 x = _offsets$x === void 0 ? 0 : _offsets$x, 2193 _offsets$y = offsets.y, 2194 y = _offsets$y === void 0 ? 0 : _offsets$y; 2195 2196 var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({ 2197 x: x, 2198 y: y 2199 }) : { 2200 x: x, 2201 y: y 2202 }; 2203 2204 x = _ref3.x; 2205 y = _ref3.y; 2206 var hasX = offsets.hasOwnProperty('x'); 2207 var hasY = offsets.hasOwnProperty('y'); 2208 var sideX = left; 2209 var sideY = top; 2210 var win = window; 2211 2212 if (adaptive) { 2213 var offsetParent = getOffsetParent(popper); 2214 var heightProp = 'clientHeight';
vendor: 16,161 bytes, lines 2215-2669
2215 var widthProp = 'clientWidth'; 2216 2217 if (offsetParent === getWindow(popper)) { 2218 offsetParent = getDocumentElement(popper); 2219 2220 if (getComputedStyle$1(offsetParent).position !== 'static' && position === 'absolute') { 2221 heightProp = 'scrollHeight'; 2222 widthProp = 'scrollWidth'; 2223 } 2224 } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it 2225 2226 2227 offsetParent = offsetParent; 2228 2229 if (placement === top || (placement === left || placement === right) && variation === end) { 2230 sideY = bottom; 2231 var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing] 2232 offsetParent[heightProp]; 2233 y -= offsetY - popperRect.height; 2234 y *= gpuAcceleration ? 1 : -1; 2235 } 2236 2237 if (placement === left || (placement === top || placement === bottom) && variation === end) { 2238 sideX = right; 2239 var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing] 2240 offsetParent[widthProp]; 2241 x -= offsetX - popperRect.width; 2242 x *= gpuAcceleration ? 1 : -1; 2243 } 2244 } 2245 2246 var commonStyles = Object.assign({ 2247 position: position 2248 }, adaptive && unsetSides); 2249 2250 var _ref4 = roundOffsets === true ? roundOffsetsByDPR({ 2251 x: x, 2252 y: y 2253 }, getWindow(popper)) : { 2254 x: x, 2255 y: y 2256 }; 2257 2258 x = _ref4.x; 2259 y = _ref4.y; 2260 2261 if (gpuAcceleration) { 2262 var _Object$assign; 2263 2264 return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign)); 2265 } 2266 2267 return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2)); 2268 } 2269 2270 function computeStyles(_ref5) { 2271 var state = _ref5.state, 2272 options = _ref5.options; 2273 var _options$gpuAccelerat = options.gpuAcceleration, 2274 gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, 2275 _options$adaptive = options.adaptive, 2276 adaptive = _options$adaptive === void 0 ? true : _options$adaptive, 2277 _options$roundOffsets = options.roundOffsets, 2278 roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets; 2279 var commonStyles = { 2280 placement: getBasePlacement(state.placement), 2281 variation: getVariation(state.placement), 2282 popper: state.elements.popper, 2283 popperRect: state.rects.popper, 2284 gpuAcceleration: gpuAcceleration, 2285 isFixed: state.options.strategy === 'fixed' 2286 }; 2287 2288 if (state.modifiersData.popperOffsets != null) { 2289 state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, { 2290 offsets: state.modifiersData.popperOffsets, 2291 position: state.options.strategy, 2292 adaptive: adaptive, 2293 roundOffsets: roundOffsets 2294 }))); 2295 } 2296 2297 if (state.modifiersData.arrow != null) { 2298 state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, { 2299 offsets: state.modifiersData.arrow, 2300 position: 'absolute', 2301 adaptive: false, 2302 roundOffsets: roundOffsets 2303 }))); 2304 } 2305 2306 state.attributes.popper = Object.assign({}, state.attributes.popper, { 2307 'data-popper-placement': state.placement 2308 }); 2309 } // eslint-disable-next-line import/no-unused-modules 2310 2311 2312 const computeStyles$1 = { 2313 name: 'computeStyles', 2314 enabled: true, 2315 phase: 'beforeWrite', 2316 fn: computeStyles, 2317 data: {} 2318 }; 2319 2320 var passive = { 2321 passive: true 2322 }; 2323 2324 function effect(_ref) { 2325 var state = _ref.state, 2326 instance = _ref.instance, 2327 options = _ref.options; 2328 var _options$scroll = options.scroll, 2329 scroll = _options$scroll === void 0 ? true : _options$scroll, 2330 _options$resize = options.resize, 2331 resize = _options$resize === void 0 ? true : _options$resize; 2332 var window = getWindow(state.elements.popper); 2333 var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper); 2334 2335 if (scroll) { 2336 scrollParents.forEach(function (scrollParent) { 2337 scrollParent.addEventListener('scroll', instance.update, passive); 2338 }); 2339 } 2340 2341 if (resize) { 2342 window.addEventListener('resize', instance.update, passive); 2343 } 2344 2345 return function () { 2346 if (scroll) { 2347 scrollParents.forEach(function (scrollParent) { 2348 scrollParent.removeEventListener('scroll', instance.update, passive); 2349 }); 2350 } 2351 2352 if (resize) { 2353 window.removeEventListener('resize', instance.update, passive); 2354 } 2355 }; 2356 } // eslint-disable-next-line import/no-unused-modules 2357 2358 2359 const eventListeners = { 2360 name: 'eventListeners', 2361 enabled: true, 2362 phase: 'write', 2363 fn: function fn() {}, 2364 effect: effect, 2365 data: {} 2366 }; 2367 2368 var hash$1 = { 2369 left: 'right', 2370 right: 'left', 2371 bottom: 'top', 2372 top: 'bottom' 2373 }; 2374 function getOppositePlacement(placement) { 2375 return placement.replace(/left|right|bottom|top/g, function (matched) { 2376 return hash$1[matched]; 2377 }); 2378 } 2379 2380 var hash = { 2381 start: 'end', 2382 end: 'start' 2383 }; 2384 function getOppositeVariationPlacement(placement) { 2385 return placement.replace(/start|end/g, function (matched) { 2386 return hash[matched]; 2387 }); 2388 } 2389 2390 function getWindowScroll(node) { 2391 var win = getWindow(node); 2392 var scrollLeft = win.pageXOffset; 2393 var scrollTop = win.pageYOffset; 2394 return { 2395 scrollLeft: scrollLeft, 2396 scrollTop: scrollTop 2397 }; 2398 } 2399 2400 function getWindowScrollBarX(element) { 2401 // If <html> has a CSS width greater than the viewport, then this will be 2402 // incorrect for RTL. 2403 // Popper 1 is broken in this case and never had a bug report so let's assume 2404 // it's not an issue. I don't think anyone ever specifies width on <html> 2405 // anyway. 2406 // Browsers where the left scrollbar doesn't cause an issue report `0` for 2407 // this (e.g. Edge 2019, IE11, Safari) 2408 return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft; 2409 } 2410 2411 function getViewportRect(element, strategy) { 2412 var win = getWindow(element); 2413 var html = getDocumentElement(element); 2414 var visualViewport = win.visualViewport; 2415 var width = html.clientWidth; 2416 var height = html.clientHeight; 2417 var x = 0; 2418 var y = 0; 2419 2420 if (visualViewport) { 2421 width = visualViewport.width; 2422 height = visualViewport.height; 2423 var layoutViewport = isLayoutViewport(); 2424 2425 if (layoutViewport || !layoutViewport && strategy === 'fixed') { 2426 x = visualViewport.offsetLeft; 2427 y = visualViewport.offsetTop; 2428 } 2429 } 2430 2431 return { 2432 width: width, 2433 height: height, 2434 x: x + getWindowScrollBarX(element), 2435 y: y 2436 }; 2437 } 2438 2439 // of the `<html>` and `<body>` rect bounds if horizontally scrollable 2440 2441 function getDocumentRect(element) { 2442 var _element$ownerDocumen; 2443 2444 var html = getDocumentElement(element); 2445 var winScroll = getWindowScroll(element); 2446 var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body; 2447 var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0); 2448 var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0); 2449 var x = -winScroll.scrollLeft + getWindowScrollBarX(element); 2450 var y = -winScroll.scrollTop; 2451 2452 if (getComputedStyle$1(body || html).direction === 'rtl') { 2453 x += max(html.clientWidth, body ? body.clientWidth : 0) - width; 2454 } 2455 2456 return { 2457 width: width, 2458 height: height, 2459 x: x, 2460 y: y 2461 }; 2462 } 2463 2464 function isScrollParent(element) { 2465 // Firefox wants us to check `-x` and `-y` variations as well 2466 var _getComputedStyle = getComputedStyle$1(element), 2467 overflow = _getComputedStyle.overflow, 2468 overflowX = _getComputedStyle.overflowX, 2469 overflowY = _getComputedStyle.overflowY; 2470 2471 return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); 2472 } 2473 2474 function getScrollParent(node) { 2475 if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) { 2476 // $FlowFixMe[incompatible-return]: assume body is always available 2477 return node.ownerDocument.body; 2478 } 2479 2480 if (isHTMLElement(node) && isScrollParent(node)) { 2481 return node; 2482 } 2483 2484 return getScrollParent(getParentNode(node)); 2485 } 2486 2487 /* 2488 given a DOM element, return the list of all scroll parents, up the list of ancesors 2489 until we get to the top window object. This list is what we attach scroll listeners 2490 to, because if any of these parent elements scroll, we'll need to re-calculate the 2491 reference element's position. 2492 */ 2493 2494 function listScrollParents(element, list) { 2495 var _element$ownerDocumen; 2496 2497 if (list === void 0) { 2498 list = []; 2499 } 2500 2501 var scrollParent = getScrollParent(element); 2502 var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body); 2503 var win = getWindow(scrollParent); 2504 var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent; 2505 var updatedList = list.concat(target); 2506 return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here 2507 updatedList.concat(listScrollParents(getParentNode(target))); 2508 } 2509 2510 function rectToClientRect(rect) { 2511 return Object.assign({}, rect, { 2512 left: rect.x, 2513 top: rect.y, 2514 right: rect.x + rect.width, 2515 bottom: rect.y + rect.height 2516 }); 2517 } 2518 2519 function getInnerBoundingClientRect(element, strategy) { 2520 var rect = getBoundingClientRect(element, false, strategy === 'fixed'); 2521 rect.top = rect.top + element.clientTop; 2522 rect.left = rect.left + element.clientLeft; 2523 rect.bottom = rect.top + element.clientHeight; 2524 rect.right = rect.left + element.clientWidth; 2525 rect.width = element.clientWidth; 2526 rect.height = element.clientHeight; 2527 rect.x = rect.left; 2528 rect.y = rect.top; 2529 return rect; 2530 } 2531 2532 function getClientRectFromMixedType(element, clippingParent, strategy) { 2533 return clippingParent === viewport ? rectToClientRect(getViewportRect(element, strategy)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element))); 2534 } // A "clipping parent" is an overflowable container with the characteristic of 2535 // clipping (or hiding) overflowing elements with a position different from 2536 // `initial` 2537 2538 2539 function getClippingParents(element) { 2540 var clippingParents = listScrollParents(getParentNode(element)); 2541 var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0; 2542 var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element; 2543 2544 if (!isElement(clipperElement)) { 2545 return []; 2546 } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414 2547 2548 2549 return clippingParents.filter(function (clippingParent) { 2550 return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body'; 2551 }); 2552 } // Gets the maximum area that the element is visible in due to any number of 2553 // clipping parents 2554 2555 2556 function getClippingRect(element, boundary, rootBoundary, strategy) { 2557 var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary); 2558 var clippingParents = [].concat(mainClippingParents, [rootBoundary]); 2559 var firstClippingParent = clippingParents[0]; 2560 var clippingRect = clippingParents.reduce(function (accRect, clippingParent) { 2561 var rect = getClientRectFromMixedType(element, clippingParent, strategy); 2562 accRect.top = max(rect.top, accRect.top); 2563 accRect.right = min(rect.right, accRect.right); 2564 accRect.bottom = min(rect.bottom, accRect.bottom); 2565 accRect.left = max(rect.left, accRect.left); 2566 return accRect; 2567 }, getClientRectFromMixedType(element, firstClippingParent, strategy)); 2568 clippingRect.width = clippingRect.right - clippingRect.left; 2569 clippingRect.height = clippingRect.bottom - clippingRect.top; 2570 clippingRect.x = clippingRect.left; 2571 clippingRect.y = clippingRect.top; 2572 return clippingRect; 2573 } 2574 2575 function computeOffsets(_ref) { 2576 var reference = _ref.reference, 2577 element = _ref.element, 2578 placement = _ref.placement; 2579 var basePlacement = placement ? getBasePlacement(placement) : null; 2580 var variation = placement ? getVariation(placement) : null; 2581 var commonX = reference.x + reference.width / 2 - element.width / 2; 2582 var commonY = reference.y + reference.height / 2 - element.height / 2; 2583 var offsets; 2584 2585 switch (basePlacement) { 2586 case top: 2587 offsets = { 2588 x: commonX, 2589 y: reference.y - element.height 2590 }; 2591 break; 2592 2593 case bottom: 2594 offsets = { 2595 x: commonX, 2596 y: reference.y + reference.height 2597 }; 2598 break; 2599 2600 case right: 2601 offsets = { 2602 x: reference.x + reference.width, 2603 y: commonY 2604 }; 2605 break; 2606 2607 case left: 2608 offsets = { 2609 x: reference.x - element.width, 2610 y: commonY 2611 }; 2612 break; 2613 2614 default: 2615 offsets = { 2616 x: reference.x, 2617 y: reference.y 2618 }; 2619 } 2620 2621 var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null; 2622 2623 if (mainAxis != null) { 2624 var len = mainAxis === 'y' ? 'height' : 'width'; 2625 2626 switch (variation) { 2627 case start: 2628 offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2); 2629 break; 2630 2631 case end: 2632 offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2); 2633 break; 2634 } 2635 } 2636 2637 return offsets; 2638 } 2639 2640 function detectOverflow(state, options) { 2641 if (options === void 0) { 2642 options = {}; 2643 } 2644 2645 var _options = options, 2646 _options$placement = _options.placement, 2647 placement = _options$placement === void 0 ? state.placement : _options$placement, 2648 _options$strategy = _options.strategy, 2649 strategy = _options$strategy === void 0 ? state.strategy : _options$strategy, 2650 _options$boundary = _options.boundary, 2651 boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, 2652 _options$rootBoundary = _options.rootBoundary, 2653 rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, 2654 _options$elementConte = _options.elementContext, 2655 elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, 2656 _options$altBoundary = _options.altBoundary, 2657 altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, 2658 _options$padding = _options.padding, 2659 padding = _options$padding === void 0 ? 0 : _options$padding; 2660 var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); 2661 var altContext = elementContext === popper ? reference : popper; 2662 var popperRect = state.rects.popper; 2663 var element = state.elements[altBoundary ? altContext : elementContext]; 2664 var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy); 2665 var referenceClientRect = getBoundingClientRect(state.elements.reference); 2666 var popperOffsets = computeOffsets({ 2667 reference: referenceClientRect, 2668 element: popperRect, 2669
2669strategy: 'absolute'
vendor: 11,222 bytes, lines 2669-2997
2669, 2670 placement: placement 2671 }); 2672 var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets)); 2673 var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect 2674 // 0 or negative = within the clipping rect 2675 2676 var overflowOffsets = { 2677 top: clippingClientRect.top - elementClientRect.top + paddingObject.top, 2678 bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom, 2679 left: clippingClientRect.left - elementClientRect.left + paddingObject.left, 2680 right: elementClientRect.right - clippingClientRect.right + paddingObject.right 2681 }; 2682 var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element 2683 2684 if (elementContext === popper && offsetData) { 2685 var offset = offsetData[placement]; 2686 Object.keys(overflowOffsets).forEach(function (key) { 2687 var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1; 2688 var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x'; 2689 overflowOffsets[key] += offset[axis] * multiply; 2690 }); 2691 } 2692 2693 return overflowOffsets; 2694 } 2695 2696 function computeAutoPlacement(state, options) { 2697 if (options === void 0) { 2698 options = {}; 2699 } 2700 2701 var _options = options, 2702 placement = _options.placement, 2703 boundary = _options.boundary, 2704 rootBoundary = _options.rootBoundary, 2705 padding = _options.padding, 2706 flipVariations = _options.flipVariations, 2707 _options$allowedAutoP = _options.allowedAutoPlacements, 2708 allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP; 2709 var variation = getVariation(placement); 2710 var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) { 2711 return getVariation(placement) === variation; 2712 }) : basePlacements; 2713 var allowedPlacements = placements$1.filter(function (placement) { 2714 return allowedAutoPlacements.indexOf(placement) >= 0; 2715 }); 2716 2717 if (allowedPlacements.length === 0) { 2718 allowedPlacements = placements$1; 2719 } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions... 2720 2721 2722 var overflows = allowedPlacements.reduce(function (acc, placement) { 2723 acc[placement] = detectOverflow(state, { 2724 placement: placement, 2725 boundary: boundary, 2726 rootBoundary: rootBoundary, 2727 padding: padding 2728 })[getBasePlacement(placement)]; 2729 return acc; 2730 }, {}); 2731 return Object.keys(overflows).sort(function (a, b) { 2732 return overflows[a] - overflows[b]; 2733 }); 2734 } 2735 2736 function getExpandedFallbackPlacements(placement) { 2737 if (getBasePlacement(placement) === auto) { 2738 return []; 2739 } 2740 2741 var oppositePlacement = getOppositePlacement(placement); 2742 return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)]; 2743 } 2744 2745 function flip(_ref) { 2746 var state = _ref.state, 2747 options = _ref.options, 2748 name = _ref.name; 2749 2750 if (state.modifiersData[name]._skip) { 2751 return; 2752 } 2753 2754 var _options$mainAxis = options.mainAxis, 2755 checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, 2756 _options$altAxis = options.altAxis, 2757 checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, 2758 specifiedFallbackPlacements = options.fallbackPlacements, 2759 padding = options.padding, 2760 boundary = options.boundary, 2761 rootBoundary = options.rootBoundary, 2762 altBoundary = options.altBoundary, 2763 _options$flipVariatio = options.flipVariations, 2764 flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, 2765 allowedAutoPlacements = options.allowedAutoPlacements; 2766 var preferredPlacement = state.options.placement; 2767 var basePlacement = getBasePlacement(preferredPlacement); 2768 var isBasePlacement = basePlacement === preferredPlacement; 2769 var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement)); 2770 var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) { 2771 return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, { 2772 placement: placement, 2773 boundary: boundary, 2774 rootBoundary: rootBoundary, 2775 padding: padding, 2776 flipVariations: flipVariations, 2777 allowedAutoPlacements: allowedAutoPlacements 2778 }) : placement); 2779 }, []); 2780 var referenceRect = state.rects.reference; 2781 var popperRect = state.rects.popper; 2782 var checksMap = new Map(); 2783 var makeFallbackChecks = true; 2784 var firstFittingPlacement = placements[0]; 2785 2786 for (var i = 0; i < placements.length; i++) { 2787 var placement = placements[i]; 2788 2789 var _basePlacement = getBasePlacement(placement); 2790 2791 var isStartVariation = getVariation(placement) === start; 2792 var isVertical = [top, bottom].indexOf(_basePlacement) >= 0; 2793 var len = isVertical ? 'width' : 'height'; 2794 var overflow = detectOverflow(state, { 2795 placement: placement, 2796 boundary: boundary, 2797 rootBoundary: rootBoundary, 2798 altBoundary: altBoundary, 2799 padding: padding 2800 }); 2801 var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top; 2802 2803 if (referenceRect[len] > popperRect[len]) { 2804 mainVariationSide = getOppositePlacement(mainVariationSide); 2805 } 2806 2807 var altVariationSide = getOppositePlacement(mainVariationSide); 2808 var checks = []; 2809 2810 if (checkMainAxis) { 2811 checks.push(overflow[_basePlacement] <= 0); 2812 } 2813 2814 if (checkAltAxis) { 2815 checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0); 2816 } 2817 2818 if (checks.every(function (check) { 2819 return check; 2820 })) { 2821 firstFittingPlacement = placement; 2822 makeFallbackChecks = false; 2823 break; 2824 } 2825 2826 checksMap.set(placement, checks); 2827 } 2828 2829 if (makeFallbackChecks) { 2830 // `2` may be desired in some cases – research later 2831 var numberOfChecks = flipVariations ? 3 : 1; 2832 2833 var _loop = function _loop(_i) { 2834 var fittingPlacement = placements.find(function (placement) { 2835 var checks = checksMap.get(placement); 2836 2837 if (checks) { 2838 return checks.slice(0, _i).every(function (check) { 2839 return check; 2840 }); 2841 } 2842 }); 2843 2844 if (fittingPlacement) { 2845 firstFittingPlacement = fittingPlacement; 2846 return "break"; 2847 } 2848 }; 2849 2850 for (var _i = numberOfChecks; _i > 0; _i--) { 2851 var _ret = _loop(_i); 2852 2853 if (_ret === "break") break; 2854 } 2855 } 2856 2857 if (state.placement !== firstFittingPlacement) { 2858 state.modifiersData[name]._skip = true; 2859 state.placement = firstFittingPlacement; 2860 state.reset = true; 2861 } 2862 } // eslint-disable-next-line import/no-unused-modules 2863 2864 2865 const flip$1 = { 2866 name: 'flip', 2867 enabled: true, 2868 phase: 'main', 2869 fn: flip, 2870 requiresIfExists: ['offset'], 2871 data: { 2872 _skip: false 2873 } 2874 }; 2875 2876 function getSideOffsets(overflow, rect, preventedOffsets) { 2877 if (preventedOffsets === void 0) { 2878 preventedOffsets = { 2879 x: 0, 2880 y: 0 2881 }; 2882 } 2883 2884 return { 2885 top: overflow.top - rect.height - preventedOffsets.y, 2886 right: overflow.right - rect.width + preventedOffsets.x, 2887 bottom: overflow.bottom - rect.height + preventedOffsets.y, 2888 left: overflow.left - rect.width - preventedOffsets.x 2889 }; 2890 } 2891 2892 function isAnySideFullyClipped(overflow) { 2893 return [top, right, bottom, left].some(function (side) { 2894 return overflow[side] >= 0; 2895 }); 2896 } 2897 2898 function hide(_ref) { 2899 var state = _ref.state, 2900 name = _ref.name; 2901 var referenceRect = state.rects.reference; 2902 var popperRect = state.rects.popper; 2903 var preventedOffsets = state.modifiersData.preventOverflow; 2904 var referenceOverflow = detectOverflow(state, { 2905 elementContext: 'reference' 2906 }); 2907 var popperAltOverflow = detectOverflow(state, { 2908 altBoundary: true 2909 }); 2910 var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect); 2911 var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets); 2912 var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets); 2913 var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets); 2914 state.modifiersData[name] = { 2915 referenceClippingOffsets: referenceClippingOffsets, 2916 popperEscapeOffsets: popperEscapeOffsets, 2917 isReferenceHidden: isReferenceHidden, 2918 hasPopperEscaped: hasPopperEscaped 2919 }; 2920 state.attributes.popper = Object.assign({}, state.attributes.popper, { 2921 'data-popper-reference-hidden': isReferenceHidden, 2922 'data-popper-escaped': hasPopperEscaped 2923 }); 2924 } // eslint-disable-next-line import/no-unused-modules 2925 2926 2927 const hide$1 = { 2928 name: 'hide', 2929 enabled: true, 2930 phase: 'main', 2931 requiresIfExists: ['preventOverflow'], 2932 fn: hide 2933 }; 2934 2935 function distanceAndSkiddingToXY(placement, rects, offset) { 2936 var basePlacement = getBasePlacement(placement); 2937 var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1; 2938 2939 var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, { 2940 placement: placement 2941 })) : offset, 2942 skidding = _ref[0], 2943 distance = _ref[1]; 2944 2945 skidding = skidding || 0; 2946 distance = (distance || 0) * invertDistance; 2947 return [left, right].indexOf(basePlacement) >= 0 ? { 2948 x: distance, 2949 y: skidding 2950 } : { 2951 x: skidding, 2952 y: distance 2953 }; 2954 } 2955 2956 function offset(_ref2) { 2957 var state = _ref2.state, 2958 options = _ref2.options, 2959 name = _ref2.name; 2960 var _options$offset = options.offset, 2961 offset = _options$offset === void 0 ? [0, 0] : _options$offset; 2962 var data = placements.reduce(function (acc, placement) { 2963 acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset); 2964 return acc; 2965 }, {}); 2966 var _data$state$placement = data[state.placement], 2967 x = _data$state$placement.x, 2968 y = _data$state$placement.y; 2969 2970 if (state.modifiersData.popperOffsets != null) { 2971 state.modifiersData.popperOffsets.x += x; 2972 state.modifiersData.popperOffsets.y += y; 2973 } 2974 2975 state.modifiersData[name] = data; 2976 } // eslint-disable-next-line import/no-unused-modules 2977 2978 2979 const offset$1 = { 2980 name: 'offset', 2981 enabled: true, 2982 phase: 'main', 2983 requires: ['popperOffsets'], 2984 fn: offset 2985 }; 2986 2987 function popperOffsets(_ref) { 2988 var state = _ref.state, 2989 name = _ref.name; 2990 // Offsets are the actual position the popper needs to have to be 2991 // properly positioned near its reference element 2992 // This is the most basic placement, and will be adjusted by 2993 // the modifiers in the next step 2994 state.modifiersData[name] = computeOffsets({ 2995 reference: state.rects.reference, 2996 element: state.rects.popper, 2997
2997strategy: 'absolute'
vendor: 16,789 bytes, lines 2997-3440
2997, 2998 placement: state.placement 2999 }); 3000 } // eslint-disable-next-line import/no-unused-modules 3001 3002 3003 const popperOffsets$1 = { 3004 name: 'popperOffsets', 3005 enabled: true, 3006 phase: 'read', 3007 fn: popperOffsets, 3008 data: {} 3009 }; 3010 3011 function getAltAxis(axis) { 3012 return axis === 'x' ? 'y' : 'x'; 3013 } 3014 3015 function preventOverflow(_ref) { 3016 var state = _ref.state, 3017 options = _ref.options, 3018 name = _ref.name; 3019 var _options$mainAxis = options.mainAxis, 3020 checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, 3021 _options$altAxis = options.altAxis, 3022 checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, 3023 boundary = options.boundary, 3024 rootBoundary = options.rootBoundary, 3025 altBoundary = options.altBoundary, 3026 padding = options.padding, 3027 _options$tether = options.tether, 3028 tether = _options$tether === void 0 ? true : _options$tether, 3029 _options$tetherOffset = options.tetherOffset, 3030 tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset; 3031 var overflow = detectOverflow(state, { 3032 boundary: boundary, 3033 rootBoundary: rootBoundary, 3034 padding: padding, 3035 altBoundary: altBoundary 3036 }); 3037 var basePlacement = getBasePlacement(state.placement); 3038 var variation = getVariation(state.placement); 3039 var isBasePlacement = !variation; 3040 var mainAxis = getMainAxisFromPlacement(basePlacement); 3041 var altAxis = getAltAxis(mainAxis); 3042 var popperOffsets = state.modifiersData.popperOffsets; 3043 var referenceRect = state.rects.reference; 3044 var popperRect = state.rects.popper; 3045 var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, { 3046 placement: state.placement 3047 })) : tetherOffset; 3048 var normalizedTetherOffsetValue = typeof tetherOffsetValue === 'number' ? { 3049 mainAxis: tetherOffsetValue, 3050 altAxis: tetherOffsetValue 3051 } : Object.assign({ 3052 mainAxis: 0, 3053 altAxis: 0 3054 }, tetherOffsetValue); 3055 var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null; 3056 var data = { 3057 x: 0, 3058 y: 0 3059 }; 3060 3061 if (!popperOffsets) { 3062 return; 3063 } 3064 3065 if (checkMainAxis) { 3066 var _offsetModifierState$; 3067 3068 var mainSide = mainAxis === 'y' ? top : left; 3069 var altSide = mainAxis === 'y' ? bottom : right; 3070 var len = mainAxis === 'y' ? 'height' : 'width'; 3071 var offset = popperOffsets[mainAxis]; 3072 var min$1 = offset + overflow[mainSide]; 3073 var max$1 = offset - overflow[altSide]; 3074 var additive = tether ? -popperRect[len] / 2 : 0; 3075 var minLen = variation === start ? referenceRect[len] : popperRect[len]; 3076 var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go 3077 // outside the reference bounds 3078 3079 var arrowElement = state.elements.arrow; 3080 var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : { 3081 width: 0, 3082 height: 0 3083 }; 3084 var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject(); 3085 var arrowPaddingMin = arrowPaddingObject[mainSide]; 3086 var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want 3087 // to include its full size in the calculation. If the reference is small 3088 // and near the edge of a boundary, the popper can overflow even if the 3089 // reference is not overflowing as well (e.g. virtual elements with no 3090 // width or height) 3091 3092 var arrowLen = within(0, referenceRect[len], arrowRect[len]); 3093 var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis; 3094 var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis; 3095 var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow); 3096 var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0; 3097 var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0; 3098 var tetherMin = offset + minOffset - offsetModifierValue - clientOffset; 3099 var tetherMax = offset + maxOffset - offsetModifierValue; 3100 var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset, tether ? max(max$1, tetherMax) : max$1); 3101 popperOffsets[mainAxis] = preventedOffset; 3102 data[mainAxis] = preventedOffset - offset; 3103 } 3104 3105 if (checkAltAxis) { 3106 var _offsetModifierState$2; 3107 3108 var _mainSide = mainAxis === 'x' ? top : left; 3109 3110 var _altSide = mainAxis === 'x' ? bottom : right; 3111 3112 var _offset = popperOffsets[altAxis]; 3113 3114 var _len = altAxis === 'y' ? 'height' : 'width'; 3115 3116 var _min = _offset + overflow[_mainSide]; 3117 3118 var _max = _offset - overflow[_altSide]; 3119 3120 var isOriginSide = [top, left].indexOf(basePlacement) !== -1; 3121 3122 var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0; 3123 3124 var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis; 3125 3126 var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max; 3127 3128 var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max); 3129 3130 popperOffsets[altAxis] = _preventedOffset; 3131 data[altAxis] = _preventedOffset - _offset; 3132 } 3133 3134 state.modifiersData[name] = data; 3135 } // eslint-disable-next-line import/no-unused-modules 3136 3137 3138 const preventOverflow$1 = { 3139 name: 'preventOverflow', 3140 enabled: true, 3141 phase: 'main', 3142 fn: preventOverflow, 3143 requiresIfExists: ['offset'] 3144 }; 3145 3146 function getHTMLElementScroll(element) { 3147 return { 3148 scrollLeft: element.scrollLeft, 3149 scrollTop: element.scrollTop 3150 }; 3151 } 3152 3153 function getNodeScroll(node) { 3154 if (node === getWindow(node) || !isHTMLElement(node)) { 3155 return getWindowScroll(node); 3156 } else { 3157 return getHTMLElementScroll(node); 3158 } 3159 } 3160 3161 function isElementScaled(element) { 3162 var rect = element.getBoundingClientRect(); 3163 var scaleX = round(rect.width) / element.offsetWidth || 1; 3164 var scaleY = round(rect.height) / element.offsetHeight || 1; 3165 return scaleX !== 1 || scaleY !== 1; 3166 } // Returns the composite rect of an element relative to its offsetParent. 3167 // Composite means it takes into account transforms as well as layout. 3168 3169 3170 function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) { 3171 if (isFixed === void 0) { 3172 isFixed = false; 3173 } 3174 3175 var isOffsetParentAnElement = isHTMLElement(offsetParent); 3176 var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent); 3177 var documentElement = getDocumentElement(offsetParent); 3178 var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed); 3179 var scroll = { 3180 scrollLeft: 0, 3181 scrollTop: 0 3182 }; 3183 var offsets = { 3184 x: 0, 3185 y: 0 3186 }; 3187 3188 if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) { 3189 if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078 3190 isScrollParent(documentElement)) { 3191 scroll = getNodeScroll(offsetParent); 3192 } 3193 3194 if (isHTMLElement(offsetParent)) { 3195 offsets = getBoundingClientRect(offsetParent, true); 3196 offsets.x += offsetParent.clientLeft; 3197 offsets.y += offsetParent.clientTop; 3198 } else if (documentElement) { 3199 offsets.x = getWindowScrollBarX(documentElement); 3200 } 3201 } 3202 3203 return { 3204 x: rect.left + scroll.scrollLeft - offsets.x, 3205 y: rect.top + scroll.scrollTop - offsets.y, 3206 width: rect.width, 3207 height: rect.height 3208 }; 3209 } 3210 3211 function order(modifiers) { 3212 var map = new Map(); 3213 var visited = new Set(); 3214 var result = []; 3215 modifiers.forEach(function (modifier) { 3216 map.set(modifier.name, modifier); 3217 }); // On visiting object, check for its dependencies and visit them recursively 3218 3219 function sort(modifier) { 3220 visited.add(modifier.name); 3221 var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []); 3222 requires.forEach(function (dep) { 3223 if (!visited.has(dep)) { 3224 var depModifier = map.get(dep); 3225 3226 if (depModifier) { 3227 sort(depModifier); 3228 } 3229 } 3230 }); 3231 result.push(modifier); 3232 } 3233 3234 modifiers.forEach(function (modifier) { 3235 if (!visited.has(modifier.name)) { 3236 // check for visited object 3237 sort(modifier); 3238 } 3239 }); 3240 return result; 3241 } 3242 3243 function orderModifiers(modifiers) { 3244 // order based on dependencies 3245 var orderedModifiers = order(modifiers); // order based on phase 3246 3247 return modifierPhases.reduce(function (acc, phase) { 3248 return acc.concat(orderedModifiers.filter(function (modifier) { 3249 return modifier.phase === phase; 3250 })); 3251 }, []); 3252 } 3253 3254 function debounce(fn) { 3255 var pending; 3256 return function () { 3257 if (!pending) { 3258 pending = new Promise(function (resolve) { 3259 Promise.resolve().then(function () { 3260 pending = undefined; 3261 resolve(fn()); 3262 }); 3263 }); 3264 } 3265 3266 return pending; 3267 }; 3268 } 3269 3270 function mergeByName(modifiers) { 3271 var merged = modifiers.reduce(function (merged, current) { 3272 var existing = merged[current.name]; 3273 merged[current.name] = existing ? Object.assign({}, existing, current, { 3274 options: Object.assign({}, existing.options, current.options), 3275 data: Object.assign({}, existing.data, current.data) 3276 }) : current; 3277 return merged; 3278 }, {}); // IE11 does not support Object.values 3279 3280 return Object.keys(merged).map(function (key) { 3281 return merged[key]; 3282 }); 3283 } 3284 3285 var DEFAULT_OPTIONS = { 3286 placement: 'bottom', 3287 modifiers: [], 3288 strategy: 'absolute' 3289 }; 3290 3291 function areValidElements() { 3292 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 3293 args[_key] = arguments[_key]; 3294 } 3295 3296 return !args.some(function (element) { 3297 return !(element && typeof element.getBoundingClientRect === 'function'); 3298 }); 3299 } 3300 3301 function popperGenerator(generatorOptions) { 3302 if (generatorOptions === void 0) { 3303 generatorOptions = {}; 3304 } 3305 3306 var _generatorOptions = generatorOptions, 3307 _generatorOptions$def = _generatorOptions.defaultModifiers, 3308 defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, 3309 _generatorOptions$def2 = _generatorOptions.defaultOptions, 3310 defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2; 3311 return function createPopper(reference, popper, options) { 3312 if (options === void 0) { 3313 options = defaultOptions; 3314 } 3315 3316 var state = { 3317 placement: 'bottom', 3318 orderedModifiers: [], 3319 options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions), 3320 modifiersData: {}, 3321 elements: { 3322 reference: reference, 3323 popper: popper 3324 }, 3325 attributes: {}, 3326 styles: {} 3327 }; 3328 var effectCleanupFns = []; 3329 var isDestroyed = false; 3330 var instance = { 3331 state: state, 3332 setOptions: function setOptions(setOptionsAction) { 3333 var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction; 3334 cleanupModifierEffects(); 3335 state.options = Object.assign({}, defaultOptions, state.options, options); 3336 state.scrollParents = { 3337 reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [], 3338 popper: listScrollParents(popper) 3339 }; // Orders the modifiers based on their dependencies and `phase` 3340 // properties 3341 3342 var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers 3343 3344 state.orderedModifiers = orderedModifiers.filter(function (m) { 3345 return m.enabled; 3346 }); 3347 runModifierEffects(); 3348 return instance.update(); 3349 }, 3350 // Sync update – it will always be executed, even if not necessary. This 3351 // is useful for low frequency updates where sync behavior simplifies the 3352 // logic. 3353 // For high frequency updates (e.g. `resize` and `scroll` events), always 3354 // prefer the async Popper#update method 3355 forceUpdate: function forceUpdate() { 3356 if (isDestroyed) { 3357 return; 3358 } 3359 3360 var _state$elements = state.elements, 3361 reference = _state$elements.reference, 3362 popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements 3363 // anymore 3364 3365 if (!areValidElements(reference, popper)) { 3366 return; 3367 } // Store the reference and popper rects to be read by modifiers 3368 3369 3370 state.rects = { 3371 reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'), 3372 popper: getLayoutRect(popper) 3373 }; // Modifiers have the ability to reset the current update cycle. The 3374 // most common use case for this is the `flip` modifier changing the 3375 // placement, which then needs to re-run all the modifiers, because the 3376 // logic was previously ran for the previous placement and is therefore 3377 // stale/incorrect 3378 3379 state.reset = false; 3380 state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier 3381 // is filled with the initial data specified by the modifier. This means 3382 // it doesn't persist and is fresh on each update. 3383 // To ensure persistent data, use `${name}#persistent` 3384 3385 state.orderedModifiers.forEach(function (modifier) { 3386 return state.modifiersData[modifier.name] = Object.assign({}, modifier.data); 3387 }); 3388 3389 for (var index = 0; index < state.orderedModifiers.length; index++) { 3390 if (state.reset === true) { 3391 state.reset = false; 3392 index = -1; 3393 continue; 3394 } 3395 3396 var _state$orderedModifie = state.orderedModifiers[index], 3397 fn = _state$orderedModifie.fn, 3398 _state$orderedModifie2 = _state$orderedModifie.options, 3399 _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, 3400 name = _state$orderedModifie.name; 3401 3402 if (typeof fn === 'function') { 3403 state = fn({ 3404 state: state, 3405 options: _options, 3406 name: name, 3407 instance: instance 3408 }) || state; 3409 } 3410 } 3411 }, 3412 // Async and optimistically optimized update – it will not be executed if 3413 // not necessary (debounced to run at most once-per-tick) 3414 update: debounce(function () { 3415 return new Promise(function (resolve) { 3416 instance.forceUpdate(); 3417 resolve(state); 3418 }); 3419 }), 3420 destroy: function destroy() { 3421 cleanupModifierEffects(); 3422 isDestroyed = true; 3423 } 3424 }; 3425 3426 if (!areValidElements(reference, popper)) { 3427 return instance; 3428 } 3429 3430 instance.setOptions(options).then(function (state) { 3431 if (!isDestroyed && options.onFirstUpdate) { 3432 options.onFirstUpdate(state); 3433 } 3434 }); // Modifiers have the ability to execute arbitrary code before the first 3435 // update cycle runs. They will be executed in the same order as the update 3436 // cycle. This is useful when a modifier adds some persistent data that 3437 // other modifiers need to use, but the modifier is run after the dependent 3438 // one. 3439 3440 function runModifierEffects() {
vendor: 8,963 bytes, lines 3441-3704
3441 state.orderedModifiers.forEach(function (_ref) { 3442 var name = _ref.name, 3443 _ref$options = _ref.options, 3444 options = _ref$options === void 0 ? {} : _ref$options, 3445 effect = _ref.effect; 3446 3447 if (typeof effect === 'function') { 3448 var cleanupFn = effect({ 3449 state: state, 3450 name: name, 3451 instance: instance, 3452 options: options 3453 }); 3454 3455 var noopFn = function noopFn() {}; 3456 3457 effectCleanupFns.push(cleanupFn || noopFn); 3458 } 3459 }); 3460 } 3461 3462 function cleanupModifierEffects() { 3463 effectCleanupFns.forEach(function (fn) { 3464 return fn(); 3465 }); 3466 effectCleanupFns = []; 3467 } 3468 3469 return instance; 3470 }; 3471 } 3472 var createPopper$2 = /*#__PURE__*/popperGenerator(); // eslint-disable-next-line import/no-unused-modules 3473 3474 var defaultModifiers$1 = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1]; 3475 var createPopper$1 = /*#__PURE__*/popperGenerator({ 3476 defaultModifiers: defaultModifiers$1 3477 }); // eslint-disable-next-line import/no-unused-modules 3478 3479 var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1]; 3480 var createPopper = /*#__PURE__*/popperGenerator({ 3481 defaultModifiers: defaultModifiers 3482 }); // eslint-disable-next-line import/no-unused-modules 3483 3484 const Popper = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({ 3485 __proto__: null, 3486 afterMain, 3487 afterRead, 3488 afterWrite, 3489 applyStyles: applyStyles$1, 3490 arrow: arrow$1, 3491 auto, 3492 basePlacements, 3493 beforeMain, 3494 beforeRead, 3495 beforeWrite, 3496 bottom, 3497 clippingParents, 3498 computeStyles: computeStyles$1, 3499 createPopper, 3500 createPopperBase: createPopper$2, 3501 createPopperLite: createPopper$1, 3502 detectOverflow, 3503 end, 3504 eventListeners, 3505 flip: flip$1, 3506 hide: hide$1, 3507 left, 3508 main, 3509 modifierPhases, 3510 offset: offset$1, 3511 placements, 3512 popper, 3513 popperGenerator, 3514 popperOffsets: popperOffsets$1, 3515 preventOverflow: preventOverflow$1, 3516 read, 3517 reference, 3518 right, 3519 start, 3520 top, 3521 variationPlacements, 3522 viewport, 3523 write 3524 }, Symbol.toStringTag, { value: 'Module' })); 3525 3526 /** 3527 * -------------------------------------------------------------------------- 3528 * Bootstrap dropdown.js 3529 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 3530 * -------------------------------------------------------------------------- 3531 */ 3532 3533 3534 /** 3535 * Constants 3536 */ 3537 3538 const NAME$a = 'dropdown'; 3539 const DATA_KEY$6 = 'bs.dropdown'; 3540 const EVENT_KEY$6 = `.${DATA_KEY$6}`; 3541 const DATA_API_KEY$3 = '.data-api'; 3542 const ESCAPE_KEY$2 = 'Escape'; 3543 const TAB_KEY$1 = 'Tab'; 3544 const ARROW_UP_KEY$1 = 'ArrowUp'; 3545 const ARROW_DOWN_KEY$1 = 'ArrowDown'; 3546 const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button 3547 3548 const EVENT_HIDE$5 = `hide${EVENT_KEY$6}`; 3549 const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$6}`; 3550 const EVENT_SHOW$5 = `show${EVENT_KEY$6}`; 3551 const EVENT_SHOWN$5 = `shown${EVENT_KEY$6}`; 3552 const EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`; 3553 const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$6}${DATA_API_KEY$3}`; 3554 const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$6}${DATA_API_KEY$3}`; 3555 const CLASS_NAME_SHOW$6 = 'show'; 3556 const CLASS_NAME_DROPUP = 'dropup'; 3557 const CLASS_NAME_DROPEND = 'dropend'; 3558 const CLASS_NAME_DROPSTART = 'dropstart'; 3559 const CLASS_NAME_DROPUP_CENTER = 'dropup-center'; 3560 const CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center'; 3561 const SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)'; 3562 const SELECTOR_DATA_TOGGLE_SHOWN = `${SELECTOR_DATA_TOGGLE$3}.${CLASS_NAME_SHOW$6}`; 3563 const SELECTOR_MENU = '.dropdown-menu'; 3564 const SELECTOR_NAVBAR = '.navbar'; 3565 const SELECTOR_NAVBAR_NAV = '.navbar-nav'; 3566 const SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'; 3567 const PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start'; 3568 const PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end'; 3569 const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start'; 3570 const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end'; 3571 const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start'; 3572 const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start'; 3573 const PLACEMENT_TOPCENTER = 'top'; 3574 const PLACEMENT_BOTTOMCENTER = 'bottom'; 3575 const Default$9 = { 3576 autoClose: true, 3577 boundary: 'clippingParents', 3578 display: 'dynamic', 3579 offset: [0, 2], 3580 popperConfig: null, 3581 reference: 'toggle' 3582 }; 3583 const DefaultType$9 = { 3584 autoClose: '(boolean|string)', 3585 boundary: '(string|element)', 3586 display: 'string', 3587 offset: '(array|string|function)', 3588 popperConfig: '(null|object|function)', 3589 reference: '(string|element|object)' 3590 }; 3591 3592 /** 3593 * Class definition 3594 */ 3595 3596 class Dropdown extends BaseComponent { 3597 constructor(element, config) { 3598 super(element, config); 3599 this._popper = null; 3600 this._parent = this._element.parentNode; // dropdown wrapper 3601 // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/ 3602 this._menu = SelectorEngine.next(this._element, SELECTOR_MENU)[0] || SelectorEngine.prev(this._element, SELECTOR_MENU)[0] || SelectorEngine.findOne(SELECTOR_MENU, this._parent); 3603 this._inNavbar = this._detectNavbar(); 3604 } 3605 3606 // Getters 3607 static get Default() { 3608 return Default$9; 3609 } 3610 static get DefaultType() { 3611 return DefaultType$9; 3612 } 3613 static get NAME() { 3614 return NAME$a; 3615 } 3616 3617 // Public 3618 toggle() { 3619 return this._isShown() ? this.hide() : this.show(); 3620 } 3621 show() { 3622 if (isDisabled(this._element) || this._isShown()) { 3623 return; 3624 } 3625 const relatedTarget = { 3626 relatedTarget: this._element 3627 }; 3628 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$5, relatedTarget); 3629 if (showEvent.defaultPrevented) { 3630 return; 3631 } 3632 this._createPopper(); 3633 3634 // If this is a touch-enabled device we add extra 3635 // empty mouseover listeners to the body's immediate children; 3636 // only needed because of broken event delegation on iOS 3637 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 3638 if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) { 3639 for (const element of [].concat(...document.body.children)) { 3640 EventHandler.on(element, 'mouseover', noop); 3641 } 3642 } 3643 this._element.focus(); 3644 this._element.setAttribute('aria-expanded', true); 3645 this._menu.classList.add(CLASS_NAME_SHOW$6); 3646 this._element.classList.add(CLASS_NAME_SHOW$6); 3647 EventHandler.trigger(this._element, EVENT_SHOWN$5, relatedTarget); 3648 } 3649 hide() { 3650 if (isDisabled(this._element) || !this._isShown()) { 3651 return; 3652 } 3653 const relatedTarget = { 3654 relatedTarget: this._element 3655 }; 3656 this._completeHide(relatedTarget); 3657 } 3658 dispose() { 3659 if (this._popper) { 3660 this._popper.destroy(); 3661 } 3662 super.dispose(); 3663 } 3664 update() { 3665 this._inNavbar = this._detectNavbar(); 3666 if (this._popper) { 3667 this._popper.update(); 3668 } 3669 } 3670 3671 // Private 3672 _completeHide(relatedTarget) { 3673 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$5, relatedTarget); 3674 if (hideEvent.defaultPrevented) { 3675 return; 3676 } 3677 3678 // If this is a touch-enabled device we remove the extra 3679 // empty mouseover listeners we added for iOS support 3680 if ('ontouchstart' in document.documentElement) { 3681 for (const element of [].concat(...document.body.children)) { 3682 EventHandler.off(element, 'mouseover', noop); 3683 } 3684 } 3685 if (this._popper) { 3686 this._popper.destroy(); 3687 } 3688 this._menu.classList.remove(CLASS_NAME_SHOW$6); 3689 this._element.classList.remove(CLASS_NAME_SHOW$6); 3690 this._element.setAttribute('aria-expanded', 'false'); 3691 Manipulator.removeDataAttribute(this._menu, 'popper'); 3692 EventHandler.trigger(this._element, EVENT_HIDDEN$5, relatedTarget); 3693 } 3694 _getConfig(config) { 3695 config = super._getConfig(config); 3696 if (typeof config.reference === 'object' && !isElement$1(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') { 3697 // Popper virtual elements require a getBoundingClientRect method 3698 throw new TypeError(`${NAME$a.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`); 3699 } 3700 return config; 3701 } 3702 _createPopper() { 3703 if (typeof Popper === 'undefined') { 3704 throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org
vendor: 2,758 bytes, lines 3704-3783
3704)'); 3705 } 3706 let referenceElement = this._element; 3707 if (this._config.reference === 'parent') { 3708 referenceElement = this._parent; 3709 } else if (isElement$1(this._config.reference)) { 3710 referenceElement = getElement(this._config.reference); 3711 } else if (typeof this._config.reference === 'object') { 3712 referenceElement = this._config.reference; 3713 } 3714 const popperConfig = this._getPopperConfig(); 3715 this._popper = createPopper(referenceElement, this._menu, popperConfig); 3716 } 3717 _isShown() { 3718 return this._menu.classList.contains(CLASS_NAME_SHOW$6); 3719 } 3720 _getPlacement() { 3721 const parentDropdown = this._parent; 3722 if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) { 3723 return PLACEMENT_RIGHT; 3724 } 3725 if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) { 3726 return PLACEMENT_LEFT; 3727 } 3728 if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) { 3729 return PLACEMENT_TOPCENTER; 3730 } 3731 if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENTER)) { 3732 return PLACEMENT_BOTTOMCENTER; 3733 } 3734 3735 // We need to trim the value because custom properties can also include spaces 3736 const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end'; 3737 if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) { 3738 return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP; 3739 } 3740 return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM; 3741 } 3742 _detectNavbar() { 3743 return this._element.closest(SELECTOR_NAVBAR) !== null; 3744 } 3745 _getOffset() { 3746 const { 3747 offset 3748 } = this._config; 3749 if (typeof offset === 'string') { 3750 return offset.split(',').map(value => Number.parseInt(value, 10)); 3751 } 3752 if (typeof offset === 'function') { 3753 return popperData => offset(popperData, this._element); 3754 } 3755 return offset; 3756 } 3757 _getPopperConfig() { 3758 const defaultBsPopperConfig = { 3759 placement: this._getPlacement(), 3760 modifiers: [{ 3761 name: 'preventOverflow', 3762 options: { 3763 boundary: this._config.boundary 3764 } 3765 }, { 3766 name: 'offset', 3767 options: { 3768 offset: this._getOffset() 3769 } 3770 }] 3771 }; 3772 3773 // Disable Popper if we have a static display or Dropdown is in Navbar 3774 if (this._inNavbar || this._config.display === 'static') { 3775 Manipulator.setDataAttribute(this._menu, 'popper', 'static'); // TODO: v6 remove 3776 defaultBsPopperConfig.modifiers = [{ 3777 name: 'applyStyles', 3778 enabled: false 3779 }]; 3780 } 3781 return { 3782 ...defaultBsPopperConfig, 3783 ...execute(this._config.popperConfig, [
vendor: 9,224 bytes, lines 3783-4087
3783defaultBsPopperConfig]) 3784 }; 3785 } 3786 _selectMenuItem({ 3787 key, 3788 target 3789 }) { 3790 const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(element => isVisible(element)); 3791 if (!items.length) { 3792 return; 3793 } 3794 3795 // if target isn't included in items (e.g. when expanding the dropdown) 3796 // allow cycling to get the last item in case key equals ARROW_UP_KEY 3797 getNextActiveElement(items, target, key === ARROW_DOWN_KEY$1, !items.includes(target)).focus(); 3798 } 3799 3800 // Static 3801 static jQueryInterface(config) { 3802 return this.each(function () { 3803 const data = Dropdown.getOrCreateInstance(this, config); 3804 if (typeof config !== 'string') { 3805 return; 3806 } 3807 if (typeof data[config] === 'undefined') { 3808 throw new TypeError(`No method named "${config}"`); 3809 } 3810 data[config](); 3811 }); 3812 } 3813 static clearMenus(event) { 3814 if (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1) { 3815 return; 3816 } 3817 const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN); 3818 for (const toggle of openToggles) { 3819 const context = Dropdown.getInstance(toggle); 3820 if (!context || context._config.autoClose === false) { 3821 continue; 3822 } 3823 const composedPath = event.composedPath(); 3824 const isMenuTarget = composedPath.includes(context._menu); 3825 if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) { 3826 continue; 3827 } 3828 3829 // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu 3830 if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) { 3831 continue; 3832 } 3833 const relatedTarget = { 3834 relatedTarget: context._element 3835 }; 3836 if (event.type === 'click') { 3837 relatedTarget.clickEvent = event; 3838 } 3839 context._completeHide(relatedTarget); 3840 } 3841 } 3842 static dataApiKeydownHandler(event) { 3843 // If not an UP | DOWN | ESCAPE key => not a dropdown command 3844 // If input/textarea && if key is other than ESCAPE => not a dropdown command 3845 3846 const isInput = /input|textarea/i.test(event.target.tagName); 3847 const isEscapeEvent = event.key === ESCAPE_KEY$2; 3848 const isUpOrDownEvent = [ARROW_UP_KEY$1, ARROW_DOWN_KEY$1].includes(event.key); 3849 if (!isUpOrDownEvent && !isEscapeEvent) { 3850 return; 3851 } 3852 if (isInput && !isEscapeEvent) { 3853 return; 3854 } 3855 event.preventDefault(); 3856 3857 // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/ 3858 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); 3859 const instance = Dropdown.getOrCreateInstance(getToggleButton); 3860 if (isUpOrDownEvent) { 3861 event.stopPropagation(); 3862 instance.show(); 3863 instance._selectMenuItem(event); 3864 return; 3865 } 3866 if (instance._isShown()) { 3867 // else is escape and we check if it is shown 3868 event.stopPropagation(); 3869 instance.hide(); 3870 getToggleButton.focus(); 3871 } 3872 } 3873 } 3874 3875 /** 3876 * Data API implementation 3877 */ 3878 3879 EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler); 3880 EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler); 3881 EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus); 3882 EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus); 3883 EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) { 3884 event.preventDefault(); 3885 Dropdown.getOrCreateInstance(this).toggle(); 3886 }); 3887 3888 /** 3889 * jQuery 3890 */ 3891 3892 defineJQueryPlugin(Dropdown); 3893 3894 /** 3895 * -------------------------------------------------------------------------- 3896 * Bootstrap util/backdrop.js 3897 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 3898 * -------------------------------------------------------------------------- 3899 */ 3900 3901 3902 /** 3903 * Constants 3904 */ 3905 3906 const NAME$9 = 'backdrop'; 3907 const CLASS_NAME_FADE$4 = 'fade'; 3908 const CLASS_NAME_SHOW$5 = 'show'; 3909 const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$9}`; 3910 const Default$8 = { 3911 className: 'modal-backdrop', 3912 clickCallback: null, 3913 isAnimated: false, 3914 isVisible: true, 3915 // if false, we use the backdrop helper without adding any element to the dom 3916 rootElement: 'body' // give the choice to place backdrop under different elements 3917 }; 3918 const DefaultType$8 = { 3919 className: 'string', 3920 clickCallback: '(function|null)', 3921 isAnimated: 'boolean', 3922 isVisible: 'boolean', 3923 rootElement: '(element|string)' 3924 }; 3925 3926 /** 3927 * Class definition 3928 */ 3929 3930 class Backdrop extends Config { 3931 constructor(config) { 3932 super(); 3933 this._config = this._getConfig(config); 3934 this._isAppended = false; 3935 this._element = null; 3936 } 3937 3938 // Getters 3939 static get Default() { 3940 return Default$8; 3941 } 3942 static get DefaultType() { 3943 return DefaultType$8; 3944 } 3945 static get NAME() { 3946 return NAME$9; 3947 } 3948 3949 // Public 3950 show(callback) { 3951 if (!this._config.isVisible) { 3952 execute(callback); 3953 return; 3954 } 3955 this._append(); 3956 const element = this._getElement(); 3957 if (this._config.isAnimated) { 3958 reflow(element); 3959 } 3960 element.classList.add(CLASS_NAME_SHOW$5); 3961 this._emulateAnimation(() => { 3962 execute(callback); 3963 }); 3964 } 3965 hide(callback) { 3966 if (!this._config.isVisible) { 3967 execute(callback); 3968 return; 3969 } 3970 this._getElement().classList.remove(CLASS_NAME_SHOW$5); 3971 this._emulateAnimation(() => { 3972 this.dispose(); 3973 execute(callback); 3974 }); 3975 } 3976 dispose() { 3977 if (!this._isAppended) { 3978 return; 3979 } 3980 EventHandler.off(this._element, EVENT_MOUSEDOWN); 3981 this._element.remove(); 3982 this._isAppended = false; 3983 } 3984 3985 // Private 3986 _getElement() { 3987 if (!this._element) { 3988 const backdrop = document.createElement('div'); 3989 backdrop.className = this._config.className; 3990 if (this._config.isAnimated) { 3991 backdrop.classList.add(CLASS_NAME_FADE$4); 3992 } 3993 this._element = backdrop; 3994 } 3995 return this._element; 3996 } 3997 _configAfterMerge(config) { 3998 // use getElement() with the default "body" to get a fresh Element on each instantiation 3999 config.rootElement = getElement(config.rootElement); 4000 return config; 4001 } 4002 _append() { 4003 if (this._isAppended) { 4004 return; 4005 } 4006 const element = this._getElement(); 4007 this._config.rootElement.append(element); 4008 EventHandler.on(element, EVENT_MOUSEDOWN, () => { 4009 execute(this._config.clickCallback); 4010 }); 4011 this._isAppended = true; 4012 } 4013 _emulateAnimation(callback) { 4014 executeAfterTransition(callback, this._getElement(), this._config.isAnimated); 4015 } 4016 } 4017 4018 /** 4019 * -------------------------------------------------------------------------- 4020 * Bootstrap util/focustrap.js 4021 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4022 * -------------------------------------------------------------------------- 4023 */ 4024 4025 4026 /** 4027 * Constants 4028 */ 4029 4030 const NAME$8 = 'focustrap'; 4031 const DATA_KEY$5 = 'bs.focustrap'; 4032 const EVENT_KEY$5 = `.${DATA_KEY$5}`; 4033 const EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$5}`; 4034 const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$5}`; 4035 const TAB_KEY = 'Tab'; 4036 const TAB_NAV_FORWARD = 'forward'; 4037 const TAB_NAV_BACKWARD = 'backward'; 4038 const Default$7 = { 4039 autofocus: true, 4040 trapElement: null // The element to trap focus inside of 4041 }; 4042 const DefaultType$7 = { 4043 autofocus: 'boolean', 4044 trapElement: 'element' 4045 }; 4046 4047 /** 4048 * Class definition 4049 */ 4050 4051 class FocusTrap extends Config { 4052 constructor(config) { 4053 super(); 4054 this._config = this._getConfig(config); 4055 this._isActive = false; 4056 this._lastTabNavDirection = null; 4057 } 4058 4059 // Getters 4060 static get Default() { 4061 return Default$7; 4062 } 4063 static get DefaultType() { 4064 return DefaultType$7; 4065 } 4066 static get NAME() { 4067 return NAME$8; 4068 } 4069 4070 // Public 4071 activate() { 4072 if (this._isActive) { 4073 return; 4074 } 4075 if (this._config.autofocus) { 4076 this._config.trapElement.focus(); 4077 } 4078 EventHandler.off(document, EVENT_KEY$5); // guard against infinite focus loop 4079 EventHandler.on(document, EVENT_FOCUSIN$2, event => this._handleFocusin(event)); 4080 EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event)); 4081 this._isActive = true; 4082 } 4083 deactivate() { 4084 if (!this._isActive) { 4085 return; 4086 } 4087 this._isActive = false;
vendor: 5,042 bytes, lines 4088-4230
4088 EventHandler.off(document, EVENT_KEY$5); 4089 } 4090 4091 // Private 4092 _handleFocusin(event) { 4093 const { 4094 trapElement 4095 } = this._config; 4096 if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) { 4097 return; 4098 } 4099 const elements = SelectorEngine.focusableChildren(trapElement); 4100 if (elements.length === 0) { 4101 trapElement.focus(); 4102 } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) { 4103 elements[elements.length - 1].focus(); 4104 } else { 4105 elements[0].focus(); 4106 } 4107 } 4108 _handleKeydown(event) { 4109 if (event.key !== TAB_KEY) { 4110 return; 4111 } 4112 this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD; 4113 } 4114 } 4115 4116 /** 4117 * -------------------------------------------------------------------------- 4118 * Bootstrap util/scrollBar.js 4119 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4120 * -------------------------------------------------------------------------- 4121 */ 4122 4123 4124 /** 4125 * Constants 4126 */ 4127 4128 const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'; 4129 const SELECTOR_STICKY_CONTENT = '.sticky-top'; 4130 const PROPERTY_PADDING = 'padding-right'; 4131 const PROPERTY_MARGIN = 'margin-right'; 4132 4133 /** 4134 * Class definition 4135 */ 4136 4137 class ScrollBarHelper { 4138 constructor() { 4139 this._element = document.body; 4140 } 4141 4142 // Public 4143 getWidth() { 4144 // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes 4145 const documentWidth = document.documentElement.clientWidth; 4146 return Math.abs(window.innerWidth - documentWidth); 4147 } 4148 hide() { 4149 const width = this.getWidth(); 4150 this._disableOverFlow(); 4151 // give padding to element to balance the hidden scrollbar width 4152 this._setElementAttributes(this._element, PROPERTY_PADDING, calculatedValue => calculatedValue + width); 4153 // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth 4154 this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, calculatedValue => calculatedValue + width); 4155 this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, calculatedValue => calculatedValue - width); 4156 } 4157 reset() { 4158 this._resetElementAttributes(this._element, 'overflow'); 4159 this._resetElementAttributes(this._element, PROPERTY_PADDING); 4160 this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING); 4161 this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN); 4162 } 4163 isOverflowing() { 4164 return this.getWidth() > 0; 4165 } 4166 4167 // Private 4168 _disableOverFlow() { 4169 this._saveInitialAttribute(this._element, 'overflow'); 4170 this._element.style.overflow = 'hidden'; 4171 } 4172 _setElementAttributes(selector, styleProperty, callback) { 4173 const scrollbarWidth = this.getWidth(); 4174 const manipulationCallBack = element => { 4175 if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) { 4176 return; 4177 } 4178 this._saveInitialAttribute(element, styleProperty); 4179 const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty); 4180 element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`); 4181 }; 4182 this._applyManipulationCallback(selector, manipulationCallBack); 4183 } 4184 _saveInitialAttribute(element, styleProperty) { 4185 const actualValue = element.style.getPropertyValue(styleProperty); 4186 if (actualValue) { 4187 Manipulator.setDataAttribute(element, styleProperty, actualValue); 4188 } 4189 } 4190 _resetElementAttributes(selector, styleProperty) { 4191 const manipulationCallBack = element => { 4192 const value = Manipulator.getDataAttribute(element, styleProperty); 4193 // We only want to remove the property if the value is `null`; the value can also be zero 4194 if (value === null) { 4195 element.style.removeProperty(styleProperty); 4196 return; 4197 } 4198 Manipulator.removeDataAttribute(element, styleProperty); 4199 element.style.setProperty(styleProperty, value); 4200 }; 4201 this._applyManipulationCallback(selector, manipulationCallBack); 4202 } 4203 _applyManipulationCallback(selector, callBack) { 4204 if (isElement$1(selector)) { 4205 callBack(selector); 4206 return; 4207 } 4208 for (const sel of SelectorEngine.find(selector, this._element)) { 4209 callBack(sel); 4210 } 4211 } 4212 } 4213 4214 /** 4215 * -------------------------------------------------------------------------- 4216 * Bootstrap modal.js 4217 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4218 * -------------------------------------------------------------------------- 4219 */ 4220 4221 4222 /** 4223 * Constants 4224 */ 4225 4226 const NAME$7 = 'modal'; 4227 const DATA_KEY$4 = 'bs.modal'; 4228 const EVENT_KEY$4 = `.${DATA_KEY$4}`; 4229 const DATA_API_KEY$2 = '.data-api'; 4230 const ESCAPE_KEY$1 = 'Escape';
vendor: 17,748 bytes, lines 4231-4805
4231 const EVENT_HIDE$4 = `hide${EVENT_KEY$4}`; 4232 const EVENT_HIDE_PREVENTED$1 = `hidePrevented${EVENT_KEY$4}`; 4233 const EVENT_HIDDEN$4 = `hidden${EVENT_KEY$4}`; 4234 const EVENT_SHOW$4 = `show${EVENT_KEY$4}`; 4235 const EVENT_SHOWN$4 = `shown${EVENT_KEY$4}`; 4236 const EVENT_RESIZE$1 = `resize${EVENT_KEY$4}`; 4237 const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY$4}`; 4238 const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$4}`; 4239 const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$4}`; 4240 const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$4}${DATA_API_KEY$2}`; 4241 const CLASS_NAME_OPEN = 'modal-open'; 4242 const CLASS_NAME_FADE$3 = 'fade'; 4243 const CLASS_NAME_SHOW$4 = 'show'; 4244 const CLASS_NAME_STATIC = 'modal-static'; 4245 const OPEN_SELECTOR$1 = '.modal.show'; 4246 const SELECTOR_DIALOG = '.modal-dialog'; 4247 const SELECTOR_MODAL_BODY = '.modal-body'; 4248 const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]'; 4249 const Default$6 = { 4250 backdrop: true, 4251 focus: true, 4252 keyboard: true 4253 }; 4254 const DefaultType$6 = { 4255 backdrop: '(boolean|string)', 4256 focus: 'boolean', 4257 keyboard: 'boolean' 4258 }; 4259 4260 /** 4261 * Class definition 4262 */ 4263 4264 class Modal extends BaseComponent { 4265 constructor(element, config) { 4266 super(element, config); 4267 this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element); 4268 this._backdrop = this._initializeBackDrop(); 4269 this._focustrap = this._initializeFocusTrap(); 4270 this._isShown = false; 4271 this._isTransitioning = false; 4272 this._scrollBar = new ScrollBarHelper(); 4273 this._addEventListeners(); 4274 } 4275 4276 // Getters 4277 static get Default() { 4278 return Default$6; 4279 } 4280 static get DefaultType() { 4281 return DefaultType$6; 4282 } 4283 static get NAME() { 4284 return NAME$7; 4285 } 4286 4287 // Public 4288 toggle(relatedTarget) { 4289 return this._isShown ? this.hide() : this.show(relatedTarget); 4290 } 4291 show(relatedTarget) { 4292 if (this._isShown || this._isTransitioning) { 4293 return; 4294 } 4295 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, { 4296 relatedTarget 4297 }); 4298 if (showEvent.defaultPrevented) { 4299 return; 4300 } 4301 this._isShown = true; 4302 this._isTransitioning = true; 4303 this._scrollBar.hide(); 4304 document.body.classList.add(CLASS_NAME_OPEN); 4305 this._adjustDialog(); 4306 this._backdrop.show(() => this._showElement(relatedTarget)); 4307 } 4308 hide() { 4309 if (!this._isShown || this._isTransitioning) { 4310 return; 4311 } 4312 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4); 4313 if (hideEvent.defaultPrevented) { 4314 return; 4315 } 4316 this._isShown = false; 4317 this._isTransitioning = true; 4318 this._focustrap.deactivate(); 4319 this._element.classList.remove(CLASS_NAME_SHOW$4); 4320 this._queueCallback(() => this._hideModal(), this._element, this._isAnimated()); 4321 } 4322 dispose() { 4323 EventHandler.off(window, EVENT_KEY$4); 4324 EventHandler.off(this._dialog, EVENT_KEY$4); 4325 this._backdrop.dispose(); 4326 this._focustrap.deactivate(); 4327 super.dispose(); 4328 } 4329 handleUpdate() { 4330 this._adjustDialog(); 4331 } 4332 4333 // Private 4334 _initializeBackDrop() { 4335 return new Backdrop({ 4336 isVisible: Boolean(this._config.backdrop), 4337 // 'static' option will be translated to true, and booleans will keep their value, 4338 isAnimated: this._isAnimated() 4339 }); 4340 } 4341 _initializeFocusTrap() { 4342 return new FocusTrap({ 4343 trapElement: this._element 4344 }); 4345 } 4346 _showElement(relatedTarget) { 4347 // try to append dynamic modal 4348 if (!document.body.contains(this._element)) { 4349 document.body.append(this._element); 4350 } 4351 this._element.style.display = 'block'; 4352 this._element.removeAttribute('aria-hidden'); 4353 this._element.setAttribute('aria-modal', true); 4354 this._element.setAttribute('role', 'dialog'); 4355 this._element.scrollTop = 0; 4356 const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog); 4357 if (modalBody) { 4358 modalBody.scrollTop = 0; 4359 } 4360 reflow(this._element); 4361 this._element.classList.add(CLASS_NAME_SHOW$4); 4362 const transitionComplete = () => { 4363 if (this._config.focus) { 4364 this._focustrap.activate(); 4365 } 4366 this._isTransitioning = false; 4367 EventHandler.trigger(this._element, EVENT_SHOWN$4, { 4368 relatedTarget 4369 }); 4370 }; 4371 this._queueCallback(transitionComplete, this._dialog, this._isAnimated()); 4372 } 4373 _addEventListeners() { 4374 EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => { 4375 if (event.key !== ESCAPE_KEY$1) { 4376 return; 4377 } 4378 if (this._config.keyboard) { 4379 this.hide(); 4380 return; 4381 } 4382 this._triggerBackdropTransition(); 4383 }); 4384 EventHandler.on(window, EVENT_RESIZE$1, () => { 4385 if (this._isShown && !this._isTransitioning) { 4386 this._adjustDialog(); 4387 } 4388 }); 4389 EventHandler.on(this._element, EVENT_MOUSEDOWN_DISMISS, event => { 4390 // a bad trick to segregate clicks that may start inside dialog but end outside, and avoid listen to scrollbar clicks 4391 EventHandler.one(this._element, EVENT_CLICK_DISMISS, event2 => { 4392 if (this._element !== event.target || this._element !== event2.target) { 4393 return; 4394 } 4395 if (this._config.backdrop === 'static') { 4396 this._triggerBackdropTransition(); 4397 return; 4398 } 4399 if (this._config.backdrop) { 4400 this.hide(); 4401 } 4402 }); 4403 }); 4404 } 4405 _hideModal() { 4406 this._element.style.display = 'none'; 4407 this._element.setAttribute('aria-hidden', true); 4408 this._element.removeAttribute('aria-modal'); 4409 this._element.removeAttribute('role'); 4410 this._isTransitioning = false; 4411 this._backdrop.hide(() => { 4412 document.body.classList.remove(CLASS_NAME_OPEN); 4413 this._resetAdjustments(); 4414 this._scrollBar.reset(); 4415 EventHandler.trigger(this._element, EVENT_HIDDEN$4); 4416 }); 4417 } 4418 _isAnimated() { 4419 return this._element.classList.contains(CLASS_NAME_FADE$3); 4420 } 4421 _triggerBackdropTransition() { 4422 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED$1); 4423 if (hideEvent.defaultPrevented) { 4424 return; 4425 } 4426 const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 4427 const initialOverflowY = this._element.style.overflowY; 4428 // return if the following background transition hasn't yet completed 4429 if (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) { 4430 return; 4431 } 4432 if (!isModalOverflowing) { 4433 this._element.style.overflowY = 'hidden'; 4434 } 4435 this._element.classList.add(CLASS_NAME_STATIC); 4436 this._queueCallback(() => { 4437 this._element.classList.remove(CLASS_NAME_STATIC); 4438 this._queueCallback(() => { 4439 this._element.style.overflowY = initialOverflowY; 4440 }, this._dialog); 4441 }, this._dialog); 4442 this._element.focus(); 4443 } 4444 4445 /** 4446 * The following methods are used to handle overflowing modals 4447 */ 4448 4449 _adjustDialog() { 4450 const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 4451 const scrollbarWidth = this._scrollBar.getWidth(); 4452 const isBodyOverflowing = scrollbarWidth > 0; 4453 if (isBodyOverflowing && !isModalOverflowing) { 4454 const property = isRTL() ? 'paddingLeft' : 'paddingRight'; 4455 this._element.style[property] = `${scrollbarWidth}px`; 4456 } 4457 if (!isBodyOverflowing && isModalOverflowing) { 4458 const property = isRTL() ? 'paddingRight' : 'paddingLeft'; 4459 this._element.style[property] = `${scrollbarWidth}px`; 4460 } 4461 } 4462 _resetAdjustments() { 4463 this._element.style.paddingLeft = ''; 4464 this._element.style.paddingRight = ''; 4465 } 4466 4467 // Static 4468 static jQueryInterface(config, relatedTarget) { 4469 return this.each(function () { 4470 const data = Modal.getOrCreateInstance(this, config); 4471 if (typeof config !== 'string') { 4472 return; 4473 } 4474 if (typeof data[config] === 'undefined') { 4475 throw new TypeError(`No method named "${config}"`); 4476 } 4477 data[config](relatedTarget); 4478 }); 4479 } 4480 } 4481 4482 /** 4483 * Data API implementation 4484 */ 4485 4486 EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) { 4487 const target = SelectorEngine.getElementFromSelector(this); 4488 if (['A', 'AREA'].includes(this.tagName)) { 4489 event.preventDefault(); 4490 } 4491 EventHandler.one(target, EVENT_SHOW$4, showEvent => { 4492 if (showEvent.defaultPrevented) { 4493 // only register focus restorer if modal will actually get shown 4494 return; 4495 } 4496 EventHandler.one(target, EVENT_HIDDEN$4, () => { 4497 if (isVisible(this)) { 4498 this.focus(); 4499 } 4500 }); 4501 }); 4502 4503 // avoid conflict when clicking modal toggler while another one is open 4504 const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1); 4505 if (alreadyOpen) { 4506 Modal.getInstance(alreadyOpen).hide(); 4507 } 4508 const data = Modal.getOrCreateInstance(target); 4509 data.toggle(this); 4510 }); 4511 enableDismissTrigger(Modal); 4512 4513 /** 4514 * jQuery 4515 */ 4516 4517 defineJQueryPlugin(Modal); 4518 4519 /** 4520 * -------------------------------------------------------------------------- 4521 * Bootstrap offcanvas.js 4522 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4523 * -------------------------------------------------------------------------- 4524 */ 4525 4526 4527 /** 4528 * Constants 4529 */ 4530 4531 const NAME$6 = 'offcanvas'; 4532 const DATA_KEY$3 = 'bs.offcanvas'; 4533 const EVENT_KEY$3 = `.${DATA_KEY$3}`; 4534 const DATA_API_KEY$1 = '.data-api'; 4535 const EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$3}${DATA_API_KEY$1}`; 4536 const ESCAPE_KEY = 'Escape'; 4537 const CLASS_NAME_SHOW$3 = 'show'; 4538 const CLASS_NAME_SHOWING$1 = 'showing'; 4539 const CLASS_NAME_HIDING = 'hiding'; 4540 const CLASS_NAME_BACKDROP = 'offcanvas-backdrop'; 4541 const OPEN_SELECTOR = '.offcanvas.show'; 4542 const EVENT_SHOW$3 = `show${EVENT_KEY$3}`; 4543 const EVENT_SHOWN$3 = `shown${EVENT_KEY$3}`; 4544 const EVENT_HIDE$3 = `hide${EVENT_KEY$3}`; 4545 const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$3}`; 4546 const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$3}`; 4547 const EVENT_RESIZE = `resize${EVENT_KEY$3}`; 4548 const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$3}${DATA_API_KEY$1}`; 4549 const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$3}`; 4550 const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]'; 4551 const Default$5 = { 4552 backdrop: true, 4553 keyboard: true, 4554 scroll: false 4555 }; 4556 const DefaultType$5 = { 4557 backdrop: '(boolean|string)', 4558 keyboard: 'boolean', 4559 scroll: 'boolean' 4560 }; 4561 4562 /** 4563 * Class definition 4564 */ 4565 4566 class Offcanvas extends BaseComponent { 4567 constructor(element, config) { 4568 super(element, config); 4569 this._isShown = false; 4570 this._backdrop = this._initializeBackDrop(); 4571 this._focustrap = this._initializeFocusTrap(); 4572 this._addEventListeners(); 4573 } 4574 4575 // Getters 4576 static get Default() { 4577 return Default$5; 4578 } 4579 static get DefaultType() { 4580 return DefaultType$5; 4581 } 4582 static get NAME() { 4583 return NAME$6; 4584 } 4585 4586 // Public 4587 toggle(relatedTarget) { 4588 return this._isShown ? this.hide() : this.show(relatedTarget); 4589 } 4590 show(relatedTarget) { 4591 if (this._isShown) { 4592 return; 4593 } 4594 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, { 4595 relatedTarget 4596 }); 4597 if (showEvent.defaultPrevented) { 4598 return; 4599 } 4600 this._isShown = true; 4601 this._backdrop.show(); 4602 if (!this._config.scroll) { 4603 new ScrollBarHelper().hide(); 4604 } 4605 this._element.setAttribute('aria-modal', true); 4606 this._element.setAttribute('role', 'dialog'); 4607 this._element.classList.add(CLASS_NAME_SHOWING$1); 4608 const completeCallBack = () => { 4609 if (!this._config.scroll || this._config.backdrop) { 4610 this._focustrap.activate(); 4611 } 4612 this._element.classList.add(CLASS_NAME_SHOW$3); 4613 this._element.classList.remove(CLASS_NAME_SHOWING$1); 4614 EventHandler.trigger(this._element, EVENT_SHOWN$3, { 4615 relatedTarget 4616 }); 4617 }; 4618 this._queueCallback(completeCallBack, this._element, true); 4619 } 4620 hide() { 4621 if (!this._isShown) { 4622 return; 4623 } 4624 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3); 4625 if (hideEvent.defaultPrevented) { 4626 return; 4627 } 4628 this._focustrap.deactivate(); 4629 this._element.blur(); 4630 this._isShown = false; 4631 this._element.classList.add(CLASS_NAME_HIDING); 4632 this._backdrop.hide(); 4633 const completeCallback = () => { 4634 this._element.classList.remove(CLASS_NAME_SHOW$3, CLASS_NAME_HIDING); 4635 this._element.removeAttribute('aria-modal'); 4636 this._element.removeAttribute('role'); 4637 if (!this._config.scroll) { 4638 new ScrollBarHelper().reset(); 4639 } 4640 EventHandler.trigger(this._element, EVENT_HIDDEN$3); 4641 }; 4642 this._queueCallback(completeCallback, this._element, true); 4643 } 4644 dispose() { 4645 this._backdrop.dispose(); 4646 this._focustrap.deactivate(); 4647 super.dispose(); 4648 } 4649 4650 // Private 4651 _initializeBackDrop() { 4652 const clickCallback = () => { 4653 if (this._config.backdrop === 'static') { 4654 EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED); 4655 return; 4656 } 4657 this.hide(); 4658 }; 4659 4660 // 'static' option will be translated to true, and booleans will keep their value 4661 const isVisible = Boolean(this._config.backdrop); 4662 return new Backdrop({ 4663 className: CLASS_NAME_BACKDROP, 4664 isVisible, 4665 isAnimated: true, 4666 rootElement: this._element.parentNode, 4667 clickCallback: isVisible ? clickCallback : null 4668 }); 4669 } 4670 _initializeFocusTrap() { 4671 return new FocusTrap({ 4672 trapElement: this._element 4673 }); 4674 } 4675 _addEventListeners() { 4676 EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => { 4677 if (event.key !== ESCAPE_KEY) { 4678 return; 4679 } 4680 if (this._config.keyboard) { 4681 this.hide(); 4682 return; 4683 } 4684 EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED); 4685 }); 4686 } 4687 4688 // Static 4689 static jQueryInterface(config) { 4690 return this.each(function () { 4691 const data = Offcanvas.getOrCreateInstance(this, config); 4692 if (typeof config !== 'string') { 4693 return; 4694 } 4695 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 4696 throw new TypeError(`No method named "${config}"`); 4697 } 4698 data[config](this); 4699 }); 4700 } 4701 } 4702 4703 /** 4704 * Data API implementation 4705 */ 4706 4707 EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) { 4708 const target = SelectorEngine.getElementFromSelector(this); 4709 if (['A', 'AREA'].includes(this.tagName)) { 4710 event.preventDefault(); 4711 } 4712 if (isDisabled(this)) { 4713 return; 4714 } 4715 EventHandler.one(target, EVENT_HIDDEN$3, () => { 4716 // focus on trigger when it is closed 4717 if (isVisible(this)) { 4718 this.focus(); 4719 } 4720 }); 4721 4722 // avoid conflict when clicking a toggler of an offcanvas, while another is open 4723 const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR); 4724 if (alreadyOpen && alreadyOpen !== target) { 4725 Offcanvas.getInstance(alreadyOpen).hide(); 4726 } 4727 const data = Offcanvas.getOrCreateInstance(target); 4728 data.toggle(this); 4729 }); 4730 EventHandler.on(window, EVENT_LOAD_DATA_API$2, () => { 4731 for (const selector of SelectorEngine.find(OPEN_SELECTOR)) { 4732 Offcanvas.getOrCreateInstance(selector).show(); 4733 } 4734 }); 4735 EventHandler.on(window, EVENT_RESIZE, () => { 4736 for (const element of SelectorEngine.find('[aria-modal][class*=show][class*=offcanvas-]')) { 4737 if (getComputedStyle(element).position !== 'fixed') { 4738 Offcanvas.getOrCreateInstance(element).hide(); 4739 } 4740 } 4741 }); 4742 enableDismissTrigger(Offcanvas); 4743 4744 /** 4745 * jQuery 4746 */ 4747 4748 defineJQueryPlugin(Offcanvas); 4749 4750 /** 4751 * -------------------------------------------------------------------------- 4752 * Bootstrap util/sanitizer.js 4753 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4754 * -------------------------------------------------------------------------- 4755 */ 4756 4757 // js-docs-start allow-list 4758 const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i; 4759 const DefaultAllowlist = { 4760 // Global attributes allowed on any supplied element below. 4761 '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN], 4762 a: ['target', 'href', 'title', 'rel'], 4763 area: [], 4764 b: [], 4765 br: [], 4766 col: [], 4767 code: [], 4768 dd: [], 4769 div: [], 4770 dl: [], 4771 dt: [], 4772 em: [], 4773 hr: [], 4774 h1: [], 4775 h2: [], 4776 h3: [], 4777 h4: [], 4778 h5: [], 4779 h6: [], 4780 i: [], 4781 img: ['src', 'srcset', 'alt', 'title', 'width', 'height'], 4782 li: [], 4783 ol: [], 4784 p: [], 4785 pre: [], 4786 s: [], 4787 small: [], 4788 span: [], 4789 sub: [], 4790 sup: [], 4791 strong: [], 4792 u: [], 4793 ul: [] 4794 }; 4795 // js-docs-end allow-list 4796 4797 const uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']); 4798 4799 /** 4800 * A pattern that recognizes URLs that are safe wrt. XSS in URL navigation 4801 * contexts. 4802 * 4803 * Shout-out to Angular https://github.com/angular/angular/blob/15.2.8/packages/core/src/sanitization/url_sanitizer.ts#L38 4804 */ 4805
vendor: 5,849 bytes, lines 4805-4996
4805// eslint-disable-next-line unicorn/better-regex 4806 const SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/i; 4807 const allowedAttribute = (attribute, allowedAttributeList) => { 4808 const attributeName = attribute.nodeName.toLowerCase(); 4809 if (allowedAttributeList.includes(attributeName)) { 4810 if (uriAttributes.has(attributeName)) { 4811 return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue)); 4812 } 4813 return true; 4814 } 4815 4816 // Check if a regular expression validates the attribute. 4817 return allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp).some(regex => regex.test(attributeName)); 4818 }; 4819 function sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) { 4820 if (!unsafeHtml.length) { 4821 return unsafeHtml; 4822 } 4823 if (sanitizeFunction && typeof sanitizeFunction === 'function') { 4824 return sanitizeFunction(unsafeHtml); 4825 } 4826 const domParser = new window.DOMParser(); 4827 const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); 4828 const elements = [].concat(...createdDocument.body.querySelectorAll('*')); 4829 for (const element of elements) { 4830 const elementName = element.nodeName.toLowerCase(); 4831 if (!Object.keys(allowList).includes(elementName)) { 4832 element.remove(); 4833 continue; 4834 } 4835 const attributeList = [].concat(...element.attributes); 4836 const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []); 4837 for (const attribute of attributeList) { 4838 if (!allowedAttribute(attribute, allowedAttributes)) { 4839 element.removeAttribute(attribute.nodeName); 4840 } 4841 } 4842 } 4843 return createdDocument.body.innerHTML; 4844 } 4845 4846 /** 4847 * -------------------------------------------------------------------------- 4848 * Bootstrap util/template-factory.js 4849 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4850 * -------------------------------------------------------------------------- 4851 */ 4852 4853 4854 /** 4855 * Constants 4856 */ 4857 4858 const NAME$5 = 'TemplateFactory'; 4859 const Default$4 = { 4860 allowList: DefaultAllowlist, 4861 content: {}, 4862 // { selector : text , selector2 : text2 , } 4863 extraClass: '', 4864 html: false, 4865 sanitize: true, 4866 sanitizeFn: null, 4867 template: '<div></div>' 4868 }; 4869 const DefaultType$4 = { 4870 allowList: 'object', 4871 content: 'object', 4872 extraClass: '(string|function)', 4873 html: 'boolean', 4874 sanitize: 'boolean', 4875 sanitizeFn: '(null|function)', 4876 template: 'string' 4877 }; 4878 const DefaultContentType = { 4879 entry: '(string|element|function|null)', 4880 selector: '(string|element)' 4881 }; 4882 4883 /** 4884 * Class definition 4885 */ 4886 4887 class TemplateFactory extends Config { 4888 constructor(config) { 4889 super(); 4890 this._config = this._getConfig(config); 4891 } 4892 4893 // Getters 4894 static get Default() { 4895 return Default$4; 4896 } 4897 static get DefaultType() { 4898 return DefaultType$4; 4899 } 4900 static get NAME() { 4901 return NAME$5; 4902 } 4903 4904 // Public 4905 getContent() { 4906 return Object.values(this._config.content).map(config => this._resolvePossibleFunction(config)).filter(Boolean); 4907 } 4908 hasContent() { 4909 return this.getContent().length > 0; 4910 } 4911 changeContent(content) { 4912 this._checkContent(content); 4913 this._config.content = { 4914 ...this._config.content, 4915 ...content 4916 }; 4917 return this; 4918 } 4919 toHtml() { 4920 const templateWrapper = document.createElement('div'); 4921 templateWrapper.innerHTML = this._maybeSanitize(this._config.template); 4922 for (const [selector, text] of Object.entries(this._config.content)) { 4923 this._setContent(templateWrapper, text, selector); 4924 } 4925 const template = templateWrapper.children[0]; 4926 const extraClass = this._resolvePossibleFunction(this._config.extraClass); 4927 if (extraClass) { 4928 template.classList.add(...extraClass.split(' ')); 4929 } 4930 return template; 4931 } 4932 4933 // Private 4934 _typeCheckConfig(config) { 4935 super._typeCheckConfig(config); 4936 this._checkContent(config.content); 4937 } 4938 _checkContent(arg) { 4939 for (const [selector, content] of Object.entries(arg)) { 4940 super._typeCheckConfig({ 4941 selector, 4942 entry: content 4943 }, DefaultContentType); 4944 } 4945 } 4946 _setContent(template, content, selector) { 4947 const templateElement = SelectorEngine.findOne(selector, template); 4948 if (!templateElement) { 4949 return; 4950 } 4951 content = this._resolvePossibleFunction(content); 4952 if (!content) { 4953 templateElement.remove(); 4954 return; 4955 } 4956 if (isElement$1(content)) { 4957 this._putElementInTemplate(getElement(content), templateElement); 4958 return; 4959 } 4960 if (this._config.html) { 4961 templateElement.innerHTML = this._maybeSanitize(content); 4962 return; 4963 } 4964 templateElement.textContent = content; 4965 } 4966 _maybeSanitize(arg) { 4967 return this._config.sanitize ? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn) : arg; 4968 } 4969 _resolvePossibleFunction(arg) { 4970 return execute(arg, [this]); 4971 } 4972 _putElementInTemplate(element, templateElement) { 4973 if (this._config.html) { 4974 templateElement.innerHTML = ''; 4975 templateElement.append(element); 4976 return; 4977 } 4978 templateElement.textContent = element.textContent; 4979 } 4980 } 4981 4982 /** 4983 * -------------------------------------------------------------------------- 4984 * Bootstrap tooltip.js 4985 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 4986 * -------------------------------------------------------------------------- 4987 */ 4988 4989 4990 /** 4991 * Constants 4992 */ 4993 4994 const NAME$4 = 'tooltip'; 4995 const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']); 4996 const CLASS_NAME_FADE$2 = 'fade';
vendor: 3,180 bytes, lines 4997-5115
4997 const CLASS_NAME_MODAL = 'modal'; 4998 const CLASS_NAME_SHOW$2 = 'show'; 4999 const SELECTOR_TOOLTIP_INNER = '.tooltip-inner'; 5000 const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`; 5001 const EVENT_MODAL_HIDE = 'hide.bs.modal'; 5002 const TRIGGER_HOVER = 'hover'; 5003 const TRIGGER_FOCUS = 'focus'; 5004 const TRIGGER_CLICK = 'click'; 5005 const TRIGGER_MANUAL = 'manual'; 5006 const EVENT_HIDE$2 = 'hide'; 5007 const EVENT_HIDDEN$2 = 'hidden'; 5008 const EVENT_SHOW$2 = 'show'; 5009 const EVENT_SHOWN$2 = 'shown'; 5010 const EVENT_INSERTED = 'inserted'; 5011 const EVENT_CLICK$1 = 'click'; 5012 const EVENT_FOCUSIN$1 = 'focusin'; 5013 const EVENT_FOCUSOUT$1 = 'focusout'; 5014 const EVENT_MOUSEENTER = 'mouseenter'; 5015 const EVENT_MOUSELEAVE = 'mouseleave'; 5016 const AttachmentMap = { 5017 AUTO: 'auto', 5018 TOP: 'top', 5019 RIGHT: isRTL() ? 'left' : 'right', 5020 BOTTOM: 'bottom', 5021 LEFT: isRTL() ? 'right' : 'left' 5022 }; 5023 const Default$3 = { 5024 allowList: DefaultAllowlist, 5025 animation: true, 5026 boundary: 'clippingParents', 5027 container: false, 5028 customClass: '', 5029 delay: 0, 5030 fallbackPlacements: ['top', 'right', 'bottom', 'left'], 5031 html: false, 5032 offset: [0, 6], 5033 placement: 'top', 5034 popperConfig: null, 5035 sanitize: true, 5036 sanitizeFn: null, 5037 selector: false, 5038 template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>', 5039 title: '', 5040 trigger: 'hover focus' 5041 }; 5042 const DefaultType$3 = { 5043 allowList: 'object', 5044 animation: 'boolean', 5045 boundary: '(string|element)', 5046 container: '(string|element|boolean)', 5047 customClass: '(string|function)', 5048 delay: '(number|object)', 5049 fallbackPlacements: 'array', 5050 html: 'boolean', 5051 offset: '(array|string|function)', 5052 placement: '(string|function)', 5053 popperConfig: '(null|object|function)', 5054 sanitize: 'boolean', 5055 sanitizeFn: '(null|function)', 5056 selector: '(string|boolean)', 5057 template: 'string', 5058 title: '(string|element|function)', 5059 trigger: 'string' 5060 }; 5061 5062 /** 5063 * Class definition 5064 */ 5065 5066 class Tooltip extends BaseComponent { 5067 constructor(element, config) { 5068 if (typeof Popper === 'undefined') { 5069 throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)'); 5070 } 5071 super(element, config); 5072 5073 // Private 5074 this._isEnabled = true; 5075 this._timeout = 0; 5076 this._isHovered = null; 5077 this._activeTrigger = {}; 5078 this._popper = null; 5079 this._templateFactory = null; 5080 this._newContent = null; 5081 5082 // Protected 5083 this.tip = null; 5084 this._setListeners(); 5085 if (!this._config.selector) { 5086 this._fixTitle(); 5087 } 5088 } 5089 5090 // Getters 5091 static get Default() { 5092 return Default$3; 5093 } 5094 static get DefaultType() { 5095 return DefaultType$3; 5096 } 5097 static get NAME() { 5098 return NAME$4; 5099 } 5100 5101 // Public 5102 enable() { 5103 this._isEnabled = true; 5104 } 5105 disable() { 5106 this._isEnabled = false; 5107 } 5108 toggleEnabled() { 5109 this._isEnabled = !this._isEnabled; 5110 } 5111 toggle() { 5112 if (!this._isEnabled) { 5113 return; 5114 } 5115 this._activeTrigger.click = !this._activeTrigger.click;
vendor: 6,078 bytes, lines 5115-5288
5115 5116 if (this._isShown()) { 5117 this._leave(); 5118 return; 5119 } 5120 this._enter(); 5121 } 5122 dispose() { 5123 clearTimeout(this._timeout); 5124 EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler); 5125 if (this._element.getAttribute('data-bs-original-title')) { 5126 this._element.setAttribute('title', this._element.getAttribute('data-bs-original-title')); 5127 } 5128 this._disposePopper(); 5129 super.dispose(); 5130 } 5131 show() { 5132 if (this._element.style.display === 'none') { 5133 throw new Error('Please use show on visible elements'); 5134 } 5135 if (!(this._isWithContent() && this._isEnabled)) { 5136 return; 5137 } 5138 const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW$2)); 5139 const shadowRoot = findShadowRoot(this._element); 5140 const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element); 5141 if (showEvent.defaultPrevented || !isInTheDom) { 5142 return; 5143 } 5144 5145 // TODO: v6 remove this or make it optional 5146 this._disposePopper(); 5147 const tip = this._getTipElement(); 5148 this._element.setAttribute('aria-describedby', tip.getAttribute('id')); 5149 const { 5150 container 5151 } = this._config; 5152 if (!this._element.ownerDocument.documentElement.contains(this.tip)) { 5153 container.append(tip); 5154 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED)); 5155 } 5156 this._popper = this._createPopper(tip); 5157 tip.classList.add(CLASS_NAME_SHOW$2); 5158 5159 // If this is a touch-enabled device we add extra 5160 // empty mouseover listeners to the body's immediate children; 5161 // only needed because of broken event delegation on iOS 5162 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 5163 if ('ontouchstart' in document.documentElement) { 5164 for (const element of [].concat(...document.body.children)) { 5165 EventHandler.on(element, 'mouseover', noop); 5166 } 5167 } 5168 const complete = () => { 5169 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOWN$2)); 5170 if (this._isHovered === false) { 5171 this._leave(); 5172 } 5173 this._isHovered = false; 5174 }; 5175 this._queueCallback(complete, this.tip, this._isAnimated()); 5176 } 5177 hide() { 5178 if (!this._isShown()) { 5179 return; 5180 } 5181 const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE$2)); 5182 if (hideEvent.defaultPrevented) { 5183 return; 5184 } 5185 const tip = this._getTipElement(); 5186 tip.classList.remove(CLASS_NAME_SHOW$2); 5187 5188 // If this is a touch-enabled device we remove the extra 5189 // empty mouseover listeners we added for iOS support 5190 if ('ontouchstart' in document.documentElement) { 5191 for (const element of [].concat(...document.body.children)) { 5192 EventHandler.off(element, 'mouseover', noop); 5193 } 5194 } 5195 this._activeTrigger[TRIGGER_CLICK] = false; 5196 this._activeTrigger[TRIGGER_FOCUS] = false; 5197 this._activeTrigger[TRIGGER_HOVER] = false; 5198 this._isHovered = null; // it is a trick to support manual triggering 5199 5200 const complete = () => { 5201 if (this._isWithActiveTrigger()) { 5202 return; 5203 } 5204 if (!this._isHovered) { 5205 this._disposePopper(); 5206 } 5207 this._element.removeAttribute('aria-describedby'); 5208 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDDEN$2)); 5209 }; 5210 this._queueCallback(complete, this.tip, this._isAnimated()); 5211 } 5212 update() { 5213 if (this._popper) { 5214 this._popper.update(); 5215 } 5216 } 5217 5218 // Protected 5219 _isWithContent() { 5220 return Boolean(this._getTitle()); 5221 } 5222 _getTipElement() { 5223 if (!this.tip) { 5224 this.tip = this._createTipElement(this._newContent || this._getContentForTemplate()); 5225 } 5226 return this.tip; 5227 } 5228 _createTipElement(content) { 5229 const tip = this._getTemplateFactory(content).toHtml(); 5230 5231 // TODO: remove this check in v6 5232 if (!tip) { 5233 return null; 5234 } 5235 tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2); 5236 // TODO: v6 the following can be achieved with CSS only 5237 tip.classList.add(`bs-${this.constructor.NAME}-auto`); 5238 const tipId = getUID(this.constructor.NAME).toString(); 5239 tip.setAttribute('id', tipId); 5240 if (this._isAnimated()) { 5241 tip.classList.add(CLASS_NAME_FADE$2); 5242 } 5243 return tip; 5244 } 5245 setContent(content) { 5246 this._newContent = content; 5247 if (this._isShown()) { 5248 this._disposePopper(); 5249 this.show(); 5250 } 5251 } 5252 _getTemplateFactory(content) { 5253 if (this._templateFactory) { 5254 this._templateFactory.changeContent(content); 5255 } else { 5256 this._templateFactory = new TemplateFactory({ 5257 ...this._config, 5258 // the `content` var has to be after `this._config` 5259 // to override config.content in case of popover 5260 content, 5261 extraClass: this._resolvePossibleFunction(this._config.customClass) 5262 }); 5263 } 5264 return this._templateFactory; 5265 } 5266 _getContentForTemplate() { 5267 return { 5268 [SELECTOR_TOOLTIP_INNER]: this._getTitle() 5269 }; 5270 } 5271 _getTitle() { 5272 return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute('data-bs-original-title'); 5273 } 5274 5275 // Private 5276 _initializeOnDelegatedTarget(event) { 5277 return this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig()); 5278 } 5279 _isAnimated() { 5280 return this._config.animation || this.tip && this.tip.classList.contains(CLASS_NAME_FADE$2); 5281 } 5282 _isShown() { 5283 return this.tip && this.tip.classList.contains(CLASS_NAME_SHOW$2); 5284 } 5285 _createPopper(tip) { 5286 const placement = execute(this._config.placement, [this, tip, this._element]); 5287 const attachment = AttachmentMap[placement.toUpperCase()]; 5288 return
vendor: 2,053 bytes, lines 5288-5349
5288createPopper(this._element, tip, this._getPopperConfig(attachment)); 5289 } 5290 _getOffset() { 5291 const { 5292 offset 5293 } = this._config; 5294 if (typeof offset === 'string') { 5295 return offset.split(',').map(value => Number.parseInt(value, 10)); 5296 } 5297 if (typeof offset === 'function') { 5298 return popperData => offset(popperData, this._element); 5299 } 5300 return offset; 5301 } 5302 _resolvePossibleFunction(arg) { 5303 return execute(arg, [this._element]); 5304 } 5305 _getPopperConfig(attachment) { 5306 const defaultBsPopperConfig = { 5307 placement: attachment, 5308 modifiers: [{ 5309 name: 'flip', 5310 options: { 5311 fallbackPlacements: this._config.fallbackPlacements 5312 } 5313 }, { 5314 name: 'offset', 5315 options: { 5316 offset: this._getOffset() 5317 } 5318 }, { 5319 name: 'preventOverflow', 5320 options: { 5321 boundary: this._config.boundary 5322 } 5323 }, { 5324 name: 'arrow', 5325 options: { 5326 element: `.${this.constructor.NAME}-arrow` 5327 } 5328 }, { 5329 name: 'preSetPlacement', 5330 enabled: true, 5331 phase: 'beforeMain', 5332 fn: data => { 5333 // Pre-set Popper's placement attribute in order to read the arrow sizes properly. 5334 // Otherwise, Popper mixes up the width and height dimensions since the initial arrow style is for top placement 5335 this._getTipElement().setAttribute('data-popper-placement', data.state.placement); 5336 } 5337 }] 5338 }; 5339 return { 5340 ...defaultBsPopperConfig, 5341 ...execute(this._config.popperConfig, [defaultBsPopperConfig]) 5342 }; 5343 } 5344 _setListeners() { 5345 const triggers = this._config.trigger.split(' '); 5346 for (const trigger of triggers) { 5347 if (trigger === 'click') { 5348 EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK$1), this._config.selector, event => { 5349 const context = this._initializeOnDelegatedTarget(event
vendor: 11,862 bytes, lines 5349-5728
5349); 5350 context.toggle(); 5351 }); 5352 } else if (trigger !== TRIGGER_MANUAL) { 5353 const eventIn = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSEENTER) : this.constructor.eventName(EVENT_FOCUSIN$1); 5354 const eventOut = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSELEAVE) : this.constructor.eventName(EVENT_FOCUSOUT$1); 5355 EventHandler.on(this._element, eventIn, this._config.selector, event => { 5356 const context = this._initializeOnDelegatedTarget(event); 5357 context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true; 5358 context._enter(); 5359 }); 5360 EventHandler.on(this._element, eventOut, this._config.selector, event => { 5361 const context = this._initializeOnDelegatedTarget(event); 5362 context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget); 5363 context._leave(); 5364 }); 5365 } 5366 } 5367 this._hideModalHandler = () => { 5368 if (this._element) { 5369 this.hide(); 5370 } 5371 }; 5372 EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler); 5373 } 5374 _fixTitle() { 5375 const title = this._element.getAttribute('title'); 5376 if (!title) { 5377 return; 5378 } 5379 if (!this._element.getAttribute('aria-label') && !this._element.textContent.trim()) { 5380 this._element.setAttribute('aria-label', title); 5381 } 5382 this._element.setAttribute('data-bs-original-title', title); // DO NOT USE IT. Is only for backwards compatibility 5383 this._element.removeAttribute('title'); 5384 } 5385 _enter() { 5386 if (this._isShown() || this._isHovered) { 5387 this._isHovered = true; 5388 return; 5389 } 5390 this._isHovered = true; 5391 this._setTimeout(() => { 5392 if (this._isHovered) { 5393 this.show(); 5394 } 5395 }, this._config.delay.show); 5396 } 5397 _leave() { 5398 if (this._isWithActiveTrigger()) { 5399 return; 5400 } 5401 this._isHovered = false; 5402 this._setTimeout(() => { 5403 if (!this._isHovered) { 5404 this.hide(); 5405 } 5406 }, this._config.delay.hide); 5407 } 5408 _setTimeout(handler, timeout) { 5409 clearTimeout(this._timeout); 5410 this._timeout = setTimeout(handler, timeout); 5411 } 5412 _isWithActiveTrigger() { 5413 return Object.values(this._activeTrigger).includes(true); 5414 } 5415 _getConfig(config) { 5416 const dataAttributes = Manipulator.getDataAttributes(this._element); 5417 for (const dataAttribute of Object.keys(dataAttributes)) { 5418 if (DISALLOWED_ATTRIBUTES.has(dataAttribute)) { 5419 delete dataAttributes[dataAttribute]; 5420 } 5421 } 5422 config = { 5423 ...dataAttributes, 5424 ...(typeof config === 'object' && config ? config : {}) 5425 }; 5426 config = this._mergeConfigObj(config); 5427 config = this._configAfterMerge(config); 5428 this._typeCheckConfig(config); 5429 return config; 5430 } 5431 _configAfterMerge(config) { 5432 config.container = config.container === false ? document.body : getElement(config.container); 5433 if (typeof config.delay === 'number') { 5434 config.delay = { 5435 show: config.delay, 5436 hide: config.delay 5437 }; 5438 } 5439 if (typeof config.title === 'number') { 5440 config.title = config.title.toString(); 5441 } 5442 if (typeof config.content === 'number') { 5443 config.content = config.content.toString(); 5444 } 5445 return config; 5446 } 5447 _getDelegateConfig() { 5448 const config = {}; 5449 for (const [key, value] of Object.entries(this._config)) { 5450 if (this.constructor.Default[key] !== value) { 5451 config[key] = value; 5452 } 5453 } 5454 config.selector = false; 5455 config.trigger = 'manual'; 5456 5457 // In the future can be replaced with: 5458 // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]]) 5459 // `Object.fromEntries(keysWithDifferentValues)` 5460 return config; 5461 } 5462 _disposePopper() { 5463 if (this._popper) { 5464 this._popper.destroy(); 5465 this._popper = null; 5466 } 5467 if (this.tip) { 5468 this.tip.remove(); 5469 this.tip = null; 5470 } 5471 } 5472 5473 // Static 5474 static jQueryInterface(config) { 5475 return this.each(function () { 5476 const data = Tooltip.getOrCreateInstance(this, config); 5477 if (typeof config !== 'string') { 5478 return; 5479 } 5480 if (typeof data[config] === 'undefined') { 5481 throw new TypeError(`No method named "${config}"`); 5482 } 5483 data[config](); 5484 }); 5485 } 5486 } 5487 5488 /** 5489 * jQuery 5490 */ 5491 5492 defineJQueryPlugin(Tooltip); 5493 5494 /** 5495 * -------------------------------------------------------------------------- 5496 * Bootstrap popover.js 5497 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5498 * -------------------------------------------------------------------------- 5499 */ 5500 5501 5502 /** 5503 * Constants 5504 */ 5505 5506 const NAME$3 = 'popover'; 5507 const SELECTOR_TITLE = '.popover-header'; 5508 const SELECTOR_CONTENT = '.popover-body'; 5509 const Default$2 = { 5510 ...Tooltip.Default, 5511 content: '', 5512 offset: [0, 8], 5513 placement: 'right', 5514 template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>', 5515 trigger: 'click' 5516 }; 5517 const DefaultType$2 = { 5518 ...Tooltip.DefaultType, 5519 content: '(null|string|element|function)' 5520 }; 5521 5522 /** 5523 * Class definition 5524 */ 5525 5526 class Popover extends Tooltip { 5527 // Getters 5528 static get Default() { 5529 return Default$2; 5530 } 5531 static get DefaultType() { 5532 return DefaultType$2; 5533 } 5534 static get NAME() { 5535 return NAME$3; 5536 } 5537 5538 // Overrides 5539 _isWithContent() { 5540 return this._getTitle() || this._getContent(); 5541 } 5542 5543 // Private 5544 _getContentForTemplate() { 5545 return { 5546 [SELECTOR_TITLE]: this._getTitle(), 5547 [SELECTOR_CONTENT]: this._getContent() 5548 }; 5549 } 5550 _getContent() { 5551 return this._resolvePossibleFunction(this._config.content); 5552 } 5553 5554 // Static 5555 static jQueryInterface(config) { 5556 return this.each(function () { 5557 const data = Popover.getOrCreateInstance(this, config); 5558 if (typeof config !== 'string') { 5559 return; 5560 } 5561 if (typeof data[config] === 'undefined') { 5562 throw new TypeError(`No method named "${config}"`); 5563 } 5564 data[config](); 5565 }); 5566 } 5567 } 5568 5569 /** 5570 * jQuery 5571 */ 5572 5573 defineJQueryPlugin(Popover); 5574 5575 /** 5576 * -------------------------------------------------------------------------- 5577 * Bootstrap scrollspy.js 5578 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5579 * -------------------------------------------------------------------------- 5580 */ 5581 5582 5583 /** 5584 * Constants 5585 */ 5586 5587 const NAME$2 = 'scrollspy'; 5588 const DATA_KEY$2 = 'bs.scrollspy'; 5589 const EVENT_KEY$2 = `.${DATA_KEY$2}`; 5590 const DATA_API_KEY = '.data-api'; 5591 const EVENT_ACTIVATE = `activate${EVENT_KEY$2}`; 5592 const EVENT_CLICK = `click${EVENT_KEY$2}`; 5593 const EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$2}${DATA_API_KEY}`; 5594 const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item'; 5595 const CLASS_NAME_ACTIVE$1 = 'active'; 5596 const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]'; 5597 const SELECTOR_TARGET_LINKS = '[href]'; 5598 const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'; 5599 const SELECTOR_NAV_LINKS = '.nav-link'; 5600 const SELECTOR_NAV_ITEMS = '.nav-item'; 5601 const SELECTOR_LIST_ITEMS = '.list-group-item'; 5602 const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`; 5603 const SELECTOR_DROPDOWN = '.dropdown'; 5604 const SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle'; 5605 const Default$1 = { 5606 offset: null, 5607 // TODO: v6 @deprecated, keep it for backwards compatibility reasons 5608 rootMargin: '0px 0px -25%', 5609 smoothScroll: false, 5610 target: null, 5611 threshold: [0.1, 0.5, 1] 5612 }; 5613 const DefaultType$1 = { 5614 offset: '(number|null)', 5615 // TODO v6 @deprecated, keep it for backwards compatibility reasons 5616 rootMargin: 'string', 5617 smoothScroll: 'boolean', 5618 target: 'element', 5619 threshold: 'array' 5620 }; 5621 5622 /** 5623 * Class definition 5624 */ 5625 5626 class ScrollSpy extends BaseComponent { 5627 constructor(element, config) { 5628 super(element, config); 5629 5630 // this._element is the observablesContainer and config.target the menu links wrapper 5631 this._targetLinks = new Map(); 5632 this._observableSections = new Map(); 5633 this._rootElement = getComputedStyle(this._element).overflowY === 'visible' ? null : this._element; 5634 this._activeTarget = null; 5635 this._observer = null; 5636 this._previousScrollData = { 5637 visibleEntryTop: 0, 5638 parentScrollTop: 0 5639 }; 5640 this.refresh(); // initialize 5641 } 5642 5643 // Getters 5644 static get Default() { 5645 return Default$1; 5646 } 5647 static get DefaultType() { 5648 return DefaultType$1; 5649 } 5650 static get NAME() { 5651 return NAME$2; 5652 } 5653 5654 // Public 5655 refresh() { 5656 this._initializeTargetsAndObservables(); 5657 this._maybeEnableSmoothScroll(); 5658 if (this._observer) { 5659 this._observer.disconnect(); 5660 } else { 5661 this._observer = this._getNewObserver(); 5662 } 5663 for (const section of this._observableSections.values()) { 5664 this._observer.observe(section); 5665 } 5666 } 5667 dispose() { 5668 this._observer.disconnect(); 5669 super.dispose(); 5670 } 5671 5672 // Private 5673 _configAfterMerge(config) { 5674 // TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case 5675 config.target = getElement(config.target) || document.body; 5676 5677 // TODO: v6 Only for backwards compatibility reasons. Use rootMargin only 5678 config.rootMargin = config.offset ? `${config.offset}px 0px -30%` : config.rootMargin; 5679 if (typeof config.threshold === 'string') { 5680 config.threshold = config.threshold.split(',').map(value => Number.parseFloat(value)); 5681 } 5682 return config; 5683 } 5684 _maybeEnableSmoothScroll() { 5685 if (!this._config.smoothScroll) { 5686 return; 5687 } 5688 5689 // unregister any previous listeners 5690 EventHandler.off(this._config.target, EVENT_CLICK); 5691 EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, event => { 5692 const observableSection = this._observableSections.get(event.target.hash); 5693 if (observableSection) { 5694 event.preventDefault(); 5695 const root = this._rootElement || window; 5696 const height = observableSection.offsetTop - this._element.offsetTop; 5697 if (root.scrollTo) { 5698 root.scrollTo({ 5699 top: height, 5700 behavior: 'smooth' 5701 }); 5702 return; 5703 } 5704 5705 // Chrome 60 doesn't support `scrollTo` 5706 root.scrollTop = height; 5707 } 5708 }); 5709 } 5710 _getNewObserver() { 5711 const options = { 5712 root: this._rootElement, 5713 threshold: this._config.threshold, 5714 rootMargin: this._config.rootMargin 5715 }; 5716 return new IntersectionObserver(entries => this._observerCallback(entries), options); 5717 } 5718 5719 // The logic of selection 5720 _observerCallback(entries) { 5721 const targetElement = entry => this._targetLinks.get(`#${entry.target.id}`); 5722 const activate = entry => { 5723 this._previousScrollData.visibleEntryTop = entry.target.offsetTop; 5724 this._process(targetElement(entry)); 5725 }; 5726 const parentScrollTop = (this._rootElement || document.documentElement).scrollTop; 5727 const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop; 5728 this._previousScrollData.parentScrollTop = parentScrollTop;
vendor: 4,660 bytes, lines 5729-5864
5729 for (const entry of entries) { 5730 if (!entry.isIntersecting) { 5731 this._activeTarget = null; 5732 this._clearActiveClass(targetElement(entry)); 5733 continue; 5734 } 5735 const entryIsLowerThanPrevious = entry.target.offsetTop >= this._previousScrollData.visibleEntryTop; 5736 // if we are scrolling down, pick the bigger offsetTop 5737 if (userScrollsDown && entryIsLowerThanPrevious) { 5738 activate(entry); 5739 // if parent isn't scrolled, let's keep the first visible item, breaking the iteration 5740 if (!parentScrollTop) { 5741 return; 5742 } 5743 continue; 5744 } 5745 5746 // if we are scrolling up, pick the smallest offsetTop 5747 if (!userScrollsDown && !entryIsLowerThanPrevious) { 5748 activate(entry); 5749 } 5750 } 5751 } 5752 _initializeTargetsAndObservables() { 5753 this._targetLinks = new Map(); 5754 this._observableSections = new Map(); 5755 const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target); 5756 for (const anchor of targetLinks) { 5757 // ensure that the anchor has an id and is not disabled 5758 if (!anchor.hash || isDisabled(anchor)) { 5759 continue; 5760 } 5761 const observableSection = SelectorEngine.findOne(decodeURI(anchor.hash), this._element); 5762 5763 // ensure that the observableSection exists & is visible 5764 if (isVisible(observableSection)) { 5765 this._targetLinks.set(decodeURI(anchor.hash), anchor); 5766 this._observableSections.set(anchor.hash, observableSection); 5767 } 5768 } 5769 } 5770 _process(target) { 5771 if (this._activeTarget === target) { 5772 return; 5773 } 5774 this._clearActiveClass(this._config.target); 5775 this._activeTarget = target; 5776 target.classList.add(CLASS_NAME_ACTIVE$1); 5777 this._activateParents(target); 5778 EventHandler.trigger(this._element, EVENT_ACTIVATE, { 5779 relatedTarget: target 5780 }); 5781 } 5782 _activateParents(target) { 5783 // Activate dropdown parents 5784 if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) { 5785 SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, target.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$1); 5786 return; 5787 } 5788 for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) { 5789 // Set triggered links parents as active 5790 // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor 5791 for (const item of SelectorEngine.prev(listGroup, SELECTOR_LINK_ITEMS)) { 5792 item.classList.add(CLASS_NAME_ACTIVE$1); 5793 } 5794 } 5795 } 5796 _clearActiveClass(parent) { 5797 parent.classList.remove(CLASS_NAME_ACTIVE$1); 5798 const activeNodes = SelectorEngine.find(`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE$1}`, parent); 5799 for (const node of activeNodes) { 5800 node.classList.remove(CLASS_NAME_ACTIVE$1); 5801 } 5802 } 5803 5804 // Static 5805 static jQueryInterface(config) { 5806 return this.each(function () { 5807 const data = ScrollSpy.getOrCreateInstance(this, config); 5808 if (typeof config !== 'string') { 5809 return; 5810 } 5811 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 5812 throw new TypeError(`No method named "${config}"`); 5813 } 5814 data[config](); 5815 }); 5816 } 5817 } 5818 5819 /** 5820 * Data API implementation 5821 */ 5822 5823 EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => { 5824 for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) { 5825 ScrollSpy.getOrCreateInstance(spy); 5826 } 5827 }); 5828 5829 /** 5830 * jQuery 5831 */ 5832 5833 defineJQueryPlugin(ScrollSpy); 5834 5835 /** 5836 * -------------------------------------------------------------------------- 5837 * Bootstrap tab.js 5838 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 5839 * -------------------------------------------------------------------------- 5840 */ 5841 5842 5843 /** 5844 * Constants 5845 */ 5846 5847 const NAME$1 = 'tab'; 5848 const DATA_KEY$1 = 'bs.tab'; 5849 const EVENT_KEY$1 = `.${DATA_KEY$1}`; 5850 const EVENT_HIDE$1 = `hide${EVENT_KEY$1}`; 5851 const EVENT_HIDDEN$1 = `hidden${EVENT_KEY$1}`; 5852 const EVENT_SHOW$1 = `show${EVENT_KEY$1}`; 5853 const EVENT_SHOWN$1 = `shown${EVENT_KEY$1}`; 5854 const EVENT_CLICK_DATA_API = `click${EVENT_KEY$1}`; 5855 const EVENT_KEYDOWN = `keydown${EVENT_KEY$1}`; 5856 const EVENT_LOAD_DATA_API = `load${EVENT_KEY$1}`; 5857 const ARROW_LEFT_KEY = 'ArrowLeft'; 5858 const ARROW_RIGHT_KEY = 'ArrowRight'; 5859 const ARROW_UP_KEY = 'ArrowUp'; 5860 const ARROW_DOWN_KEY = 'ArrowDown'; 5861 const HOME_KEY = 'Home'; 5862 const END_KEY = 'End'; 5863 const CLASS_NAME_ACTIVE = 'active'; 5864 const CLASS_NAME_FADE$1 = 'fade';
vendor: 6,276 bytes, lines 5865-6027
5865 const CLASS_NAME_SHOW$1 = 'show'; 5866 const CLASS_DROPDOWN = 'dropdown'; 5867 const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'; 5868 const SELECTOR_DROPDOWN_MENU = '.dropdown-menu'; 5869 const NOT_SELECTOR_DROPDOWN_TOGGLE = `:not(${SELECTOR_DROPDOWN_TOGGLE})`; 5870 const SELECTOR_TAB_PANEL = '.list-group, .nav, [role="tablist"]'; 5871 const SELECTOR_OUTER = '.nav-item, .list-group-item'; 5872 const SELECTOR_INNER = `.nav-link${NOT_SELECTOR_DROPDOWN_TOGGLE}, .list-group-item${NOT_SELECTOR_DROPDOWN_TOGGLE}, [role="tab"]${NOT_SELECTOR_DROPDOWN_TOGGLE}`; 5873 const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]'; // TODO: could only be `tab` in v6 5874 const SELECTOR_INNER_ELEM = `${SELECTOR_INNER}, ${SELECTOR_DATA_TOGGLE}`; 5875 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"]`; 5876 5877 /** 5878 * Class definition 5879 */ 5880 5881 class Tab extends BaseComponent { 5882 constructor(element) { 5883 super(element); 5884 this._parent = this._element.closest(SELECTOR_TAB_PANEL); 5885 if (!this._parent) { 5886 return; 5887 // TODO: should throw exception in v6 5888 // throw new TypeError(`${element.outerHTML} has not a valid parent ${SELECTOR_INNER_ELEM}`) 5889 } 5890 5891 // Set up initial aria attributes 5892 this._setInitialAttributes(this._parent, this._getChildren()); 5893 EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event)); 5894 } 5895 5896 // Getters 5897 static get NAME() { 5898 return NAME$1; 5899 } 5900 5901 // Public 5902 show() { 5903 // Shows this elem and deactivate the active sibling if exists 5904 const innerElem = this._element; 5905 if (this._elemIsActive(innerElem)) { 5906 return; 5907 } 5908 5909 // Search for active tab on same parent to deactivate it 5910 const active = this._getActiveElem(); 5911 const hideEvent = active ? EventHandler.trigger(active, EVENT_HIDE$1, { 5912 relatedTarget: innerElem 5913 }) : null; 5914 const showEvent = EventHandler.trigger(innerElem, EVENT_SHOW$1, { 5915 relatedTarget: active 5916 }); 5917 if (showEvent.defaultPrevented || hideEvent && hideEvent.defaultPrevented) { 5918 return; 5919 } 5920 this._deactivate(active, innerElem); 5921 this._activate(innerElem, active); 5922 } 5923 5924 // Private 5925 _activate(element, relatedElem) { 5926 if (!element) { 5927 return; 5928 } 5929 element.classList.add(CLASS_NAME_ACTIVE); 5930 this._activate(SelectorEngine.getElementFromSelector(element)); // Search and activate/show the proper section 5931 5932 const complete = () => { 5933 if (element.getAttribute('role') !== 'tab') { 5934 element.classList.add(CLASS_NAME_SHOW$1); 5935 return; 5936 } 5937 element.removeAttribute('tabindex'); 5938 element.setAttribute('aria-selected', true); 5939 this._toggleDropDown(element, true); 5940 EventHandler.trigger(element, EVENT_SHOWN$1, { 5941 relatedTarget: relatedElem 5942 }); 5943 }; 5944 this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1)); 5945 } 5946 _deactivate(element, relatedElem) { 5947 if (!element) { 5948 return; 5949 } 5950 element.classList.remove(CLASS_NAME_ACTIVE); 5951 element.blur(); 5952 this._deactivate(SelectorEngine.getElementFromSelector(element)); // Search and deactivate the shown section too 5953 5954 const complete = () => { 5955 if (element.getAttribute('role') !== 'tab') { 5956 element.classList.remove(CLASS_NAME_SHOW$1); 5957 return; 5958 } 5959 element.setAttribute('aria-selected', false); 5960 element.setAttribute('tabindex', '-1'); 5961 this._toggleDropDown(element, false); 5962 EventHandler.trigger(element, EVENT_HIDDEN$1, { 5963 relatedTarget: relatedElem 5964 }); 5965 }; 5966 this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1)); 5967 } 5968 _keydown(event) { 5969 if (![ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY, HOME_KEY, END_KEY].includes(event.key)) { 5970 return; 5971 } 5972 event.stopPropagation(); // stopPropagation/preventDefault both added to support up/down keys without scrolling the page 5973 event.preventDefault(); 5974 const children = this._getChildren().filter(element => !isDisabled(element)); 5975 let nextActiveElement; 5976 if ([HOME_KEY, END_KEY].includes(event.key)) { 5977 nextActiveElement = children[event.key === HOME_KEY ? 0 : children.length - 1]; 5978 } else { 5979 const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key); 5980 nextActiveElement = getNextActiveElement(children, event.target, isNext, true); 5981 } 5982 if (nextActiveElement) { 5983 nextActiveElement.focus({ 5984 preventScroll: true 5985 }); 5986 Tab.getOrCreateInstance(nextActiveElement).show(); 5987 } 5988 } 5989 _getChildren() { 5990 // collection of inner elements 5991 return SelectorEngine.find(SELECTOR_INNER_ELEM, this._parent); 5992 } 5993 _getActiveElem() { 5994 return this._getChildren().find(child => this._elemIsActive(child)) || null; 5995 } 5996 _setInitialAttributes(parent, children) { 5997 this._setAttributeIfNotExists(parent, 'role', 'tablist'); 5998 for (const child of children) { 5999 this._setInitialAttributesOnChild(child); 6000 } 6001 } 6002 _setInitialAttributesOnChild(child) { 6003 child = this._getInnerElement(child); 6004 const isActive = this._elemIsActive(child); 6005 const outerElem = this._getOuterElement(child); 6006 child.setAttribute('aria-selected', isActive); 6007 if (outerElem !== child) { 6008 this._setAttributeIfNotExists(outerElem, 'role', 'presentation'); 6009 } 6010 if (!isActive) { 6011 child.setAttribute('tabindex', '-1'); 6012 } 6013 this._setAttributeIfNotExists(child, 'role', 'tab'); 6014 6015 // set attributes to the related panel too 6016 this._setInitialAttributesOnTargetPanel(child); 6017 } 6018 _setInitialAttributesOnTargetPanel(child) { 6019 const target = SelectorEngine.getElementFromSelector(child); 6020 if (!target) { 6021 return; 6022 } 6023 this._setAttributeIfNotExists(target, 'role', 'tabpanel'); 6024 if (child.id) { 6025 this._setAttributeIfNotExists(target, 'aria-labelledby', `${child.id}`); 6026 } 6027 }
vendor: 5,385 bytes, lines 6028-6214
6028 _toggleDropDown(element, open) { 6029 const outerElem = this._getOuterElement(element); 6030 if (!outerElem.classList.contains(CLASS_DROPDOWN)) { 6031 return; 6032 } 6033 const toggle = (selector, className) => { 6034 const element = SelectorEngine.findOne(selector, outerElem); 6035 if (element) { 6036 element.classList.toggle(className, open); 6037 } 6038 }; 6039 toggle(SELECTOR_DROPDOWN_TOGGLE, CLASS_NAME_ACTIVE); 6040 toggle(SELECTOR_DROPDOWN_MENU, CLASS_NAME_SHOW$1); 6041 outerElem.setAttribute('aria-expanded', open); 6042 } 6043 _setAttributeIfNotExists(element, attribute, value) { 6044 if (!element.hasAttribute(attribute)) { 6045 element.setAttribute(attribute, value); 6046 } 6047 } 6048 _elemIsActive(elem) { 6049 return elem.classList.contains(CLASS_NAME_ACTIVE); 6050 } 6051 6052 // Try to get the inner element (usually the .nav-link) 6053 _getInnerElement(elem) { 6054 return elem.matches(SELECTOR_INNER_ELEM) ? elem : SelectorEngine.findOne(SELECTOR_INNER_ELEM, elem); 6055 } 6056 6057 // Try to get the outer element (usually the .nav-item) 6058 _getOuterElement(elem) { 6059 return elem.closest(SELECTOR_OUTER) || elem; 6060 } 6061 6062 // Static 6063 static jQueryInterface(config) { 6064 return this.each(function () { 6065 const data = Tab.getOrCreateInstance(this); 6066 if (typeof config !== 'string') { 6067 return; 6068 } 6069 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 6070 throw new TypeError(`No method named "${config}"`); 6071 } 6072 data[config](); 6073 }); 6074 } 6075 } 6076 6077 /** 6078 * Data API implementation 6079 */ 6080 6081 EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { 6082 if (['A', 'AREA'].includes(this.tagName)) { 6083 event.preventDefault(); 6084 } 6085 if (isDisabled(this)) { 6086 return; 6087 } 6088 Tab.getOrCreateInstance(this).show(); 6089 }); 6090 6091 /** 6092 * Initialize on focus 6093 */ 6094 EventHandler.on(window, EVENT_LOAD_DATA_API, () => { 6095 for (const element of SelectorEngine.find(SELECTOR_DATA_TOGGLE_ACTIVE)) { 6096 Tab.getOrCreateInstance(element); 6097 } 6098 }); 6099 /** 6100 * jQuery 6101 */ 6102 6103 defineJQueryPlugin(Tab); 6104 6105 /** 6106 * -------------------------------------------------------------------------- 6107 * Bootstrap toast.js 6108 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6109 * -------------------------------------------------------------------------- 6110 */ 6111 6112 6113 /** 6114 * Constants 6115 */ 6116 6117 const NAME = 'toast'; 6118 const DATA_KEY = 'bs.toast'; 6119 const EVENT_KEY = `.${DATA_KEY}`; 6120 const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`; 6121 const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`; 6122 const EVENT_FOCUSIN = `focusin${EVENT_KEY}`; 6123 const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`; 6124 const EVENT_HIDE = `hide${EVENT_KEY}`; 6125 const EVENT_HIDDEN = `hidden${EVENT_KEY}`; 6126 const EVENT_SHOW = `show${EVENT_KEY}`; 6127 const EVENT_SHOWN = `shown${EVENT_KEY}`; 6128 const CLASS_NAME_FADE = 'fade'; 6129 const CLASS_NAME_HIDE = 'hide'; // @deprecated - kept here only for backwards compatibility 6130 const CLASS_NAME_SHOW = 'show'; 6131 const CLASS_NAME_SHOWING = 'showing'; 6132 const DefaultType = { 6133 animation: 'boolean', 6134 autohide: 'boolean', 6135 delay: 'number' 6136 }; 6137 const Default = { 6138 animation: true, 6139 autohide: true, 6140 delay: 5000 6141 }; 6142 6143 /** 6144 * Class definition 6145 */ 6146 6147 class Toast extends BaseComponent { 6148 constructor(element, config) { 6149 super(element, config); 6150 this._timeout = null; 6151 this._hasMouseInteraction = false; 6152 this._hasKeyboardInteraction = false; 6153 this._setListeners(); 6154 } 6155 6156 // Getters 6157 static get Default() { 6158 return Default; 6159 } 6160 static get DefaultType() { 6161 return DefaultType; 6162 } 6163 static get NAME() { 6164 return NAME; 6165 } 6166 6167 // Public 6168 show() { 6169 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW); 6170 if (showEvent.defaultPrevented) { 6171 return; 6172 } 6173 this._clearTimeout(); 6174 if (this._config.animation) { 6175 this._element.classList.add(CLASS_NAME_FADE); 6176 } 6177 const complete = () => { 6178 this._element.classList.remove(CLASS_NAME_SHOWING); 6179 EventHandler.trigger(this._element, EVENT_SHOWN); 6180 this._maybeScheduleHide(); 6181 }; 6182 this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated 6183 reflow(this._element); 6184 this._element.classList.add(CLASS_NAME_SHOW, CLASS_NAME_SHOWING); 6185 this._queueCallback(complete, this._element, this._config.animation); 6186 } 6187 hide() { 6188 if (!this.isShown()) { 6189 return; 6190 } 6191 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE); 6192 if (hideEvent.defaultPrevented) { 6193 return; 6194 } 6195 const complete = () => { 6196 this._element.classList.add(CLASS_NAME_HIDE); // @deprecated 6197 this._element.classList.remove(CLASS_NAME_SHOWING, CLASS_NAME_SHOW); 6198 EventHandler.trigger(this._element, EVENT_HIDDEN); 6199 }; 6200 this._element.classList.add(CLASS_NAME_SHOWING); 6201 this._queueCallback(complete, this._element, this._config.animation); 6202 } 6203 dispose() { 6204 this._clearTimeout(); 6205 if (this.isShown()) { 6206 this._element.classList.remove(CLASS_NAME_SHOW); 6207 } 6208 super.dispose(); 6209 } 6210 isShown() { 6211 return this._element.classList.contains(CLASS_NAME_SHOW); 6212 } 6213 6214 // Private
vendor: 2,482 bytes, lines 6215-6314
6215 6216 _maybeScheduleHide() { 6217 if (!this._config.autohide) { 6218 return; 6219 } 6220 if (this._hasMouseInteraction || this._hasKeyboardInteraction) { 6221 return; 6222 } 6223 this._timeout = setTimeout(() => { 6224 this.hide(); 6225 }, this._config.delay); 6226 } 6227 _onInteraction(event, isInteracting) { 6228 switch (event.type) { 6229 case 'mouseover': 6230 case 'mouseout': 6231 { 6232 this._hasMouseInteraction = isInteracting; 6233 break; 6234 } 6235 case 'focusin': 6236 case 'focusout': 6237 { 6238 this._hasKeyboardInteraction = isInteracting; 6239 break; 6240 } 6241 } 6242 if (isInteracting) { 6243 this._clearTimeout(); 6244 return; 6245 } 6246 const nextElement = event.relatedTarget; 6247 if (this._element === nextElement || this._element.contains(nextElement)) { 6248 return; 6249 } 6250 this._maybeScheduleHide(); 6251 } 6252 _setListeners() { 6253 EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true)); 6254 EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false)); 6255 EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true)); 6256 EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false)); 6257 } 6258 _clearTimeout() { 6259 clearTimeout(this._timeout); 6260 this._timeout = null; 6261 } 6262 6263 // Static 6264 static jQueryInterface(config) { 6265 return this.each(function () { 6266 const data = Toast.getOrCreateInstance(this, config); 6267 if (typeof config === 'string') { 6268 if (typeof data[config] === 'undefined') { 6269 throw new TypeError(`No method named "${config}"`); 6270 } 6271 data[config](this); 6272 } 6273 }); 6274 } 6275 } 6276 6277 /** 6278 * Data API implementation 6279 */ 6280 6281 enableDismissTrigger(Toast); 6282 6283 /** 6284 * jQuery 6285 */ 6286 6287 defineJQueryPlugin(Toast); 6288 6289 /** 6290 * -------------------------------------------------------------------------- 6291 * Bootstrap index.umd.js 6292 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 6293 * -------------------------------------------------------------------------- 6294 */ 6295 6296 const index_umd = { 6297 Alert, 6298 Button, 6299 Carousel, 6300 Collapse, 6301 Dropdown, 6302 Modal, 6303 Offcanvas, 6304 Popover, 6305 ScrollSpy, 6306 Tab, 6307 Toast, 6308 Tooltip 6309 }; 6310 6311 return index_umd; 6312 6313})); 6314//# sourceMappingURL=bootstrap.bundle.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.