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