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