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