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