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