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