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