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)
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';
12 $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
13 Popper = Popper && Popper.hasOwnProperty('default') ? Popper['default'] : Popper;
15 function _defineProperties(target, props) {
16 for (var i = 0; i < props.length; i++) {
17 var descriptor = props[i];
18 descriptor.enumerable = descriptor.enumerable || false;
19 descriptor.configurable = true;
20 if ("value" in descriptor) descriptor.writable = true;
21 Object.defineProperty(target, descriptor.key, descriptor);
25 function _createClass(Constructor, protoProps, staticProps) {
26 if (protoProps) _defineProperties(Constructor.prototype, protoProps);
27 if (staticProps) _defineProperties(Constructor, staticProps);
32 _extends = Object.assign || function (target) {
33 for (var i = 1; i < arguments.length; i++) {
34 var source = arguments[i];
36 for (var key in source) {
37 if (Object.prototype.hasOwnProperty.call(source, key)) {
38 target[key] = source[key];
46 return _extends.apply(this, arguments);
49 function _inheritsLoose(subClass, superClass) {
50 subClass.prototype = Object.create(superClass.prototype);
51 subClass.prototype.constructor = subClass;
52 subClass.__proto__ = superClass;
56 * --------------------------------------------------------------------------
57 * Bootstrap (v4.0.0): util.js
58 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
59 * --------------------------------------------------------------------------
62 var Util = function ($$$1) {
64 * ------------------------------------------------------------------------
65 * Private TransitionEnd Helpers
66 * ------------------------------------------------------------------------
68 var transition = false;
69 var MAX_UID = 1000000; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
71 function toType(obj) {
72 return {}.toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase();
75 function getSpecialTransitionEndEvent() {
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
84 return undefined; // eslint-disable-line no-undefined
89 function transitionEndTest() {
90 if (typeof window !== 'undefined' && window.QUnit) {
99 function transitionEndEmulator(duration) {
103 $$$1(this).one(Util.TRANSITION_END, function () {
106 setTimeout(function () {
108 Util.triggerTransitionEnd(_this);
114 function setTransitionEndSupport() {
115 transition = transitionEndTest();
116 $$$1.fn.emulateTransitionEnd = transitionEndEmulator;
118 if (Util.supportsTransitionEnd()) {
119 $$$1.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
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');
130 * --------------------------------------------------------------------------
132 * --------------------------------------------------------------------------
137 TRANSITION_END: 'bsTransitionEnd',
138 getUID: function getUID(prefix) {
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));
146 getSelectorFromElement: function getSelectorFromElement(element) {
147 var selector = element.getAttribute('data-target');
149 if (!selector || selector === '#') {
150 selector = element.getAttribute('href') || '';
154 if (selector.charAt(0) === '#') {
155 selector = escapeId(selector);
159 var $selector = $$$1(document).find(selector);
160 return $selector.length > 0 ? selector : null;
165 reflow: function reflow(element) {
166 return element.offsetHeight;
168 triggerTransitionEnd: function triggerTransitionEnd(element) {
169 $$$1(element).trigger(transition.end);
171 supportsTransitionEnd: function supportsTransitionEnd() {
172 return Boolean(transition);
174 isElement: function isElement(obj) {
175 return (obj[0] || obj).nodeType;
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);
184 if (!new RegExp(expectedTypes).test(valueType)) {
185 throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
191 setTransitionEndSupport();
196 * --------------------------------------------------------------------------
197 * Bootstrap (v4.0.0): alert.js
198 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
199 * --------------------------------------------------------------------------
202 var Alert = function ($$$1) {
204 * ------------------------------------------------------------------------
206 * ------------------------------------------------------------------------
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;
216 DISMISS: '[data-dismiss="alert"]'
219 CLOSE: "close" + EVENT_KEY,
220 CLOSED: "closed" + EVENT_KEY,
221 CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
228 * ------------------------------------------------------------------------
230 * ------------------------------------------------------------------------
238 function Alert(element) {
239 this._element = element;
243 var _proto = Alert.prototype;
246 _proto.close = function close(element) {
247 element = element || this._element;
249 var rootElement = this._getRootElement(element);
251 var customEvent = this._triggerCloseEvent(rootElement);
253 if (customEvent.isDefaultPrevented()) {
257 this._removeElement(rootElement);
260 _proto.dispose = function dispose() {
261 $$$1.removeData(this._element, DATA_KEY);
262 this._element = null;
266 _proto._getRootElement = function _getRootElement(element) {
267 var selector = Util.getSelectorFromElement(element);
271 parent = $$$1(selector)[0];
275 parent = $$$1(element).closest("." + ClassName.ALERT)[0];
281 _proto._triggerCloseEvent = function _triggerCloseEvent(element) {
282 var closeEvent = $$$1.Event(Event.CLOSE);
283 $$$1(element).trigger(closeEvent);
287 _proto._removeElement = function _removeElement(element) {
290 $$$1(element).removeClass(ClassName.SHOW);
292 if (!Util.supportsTransitionEnd() || !$$$1(element).hasClass(ClassName.FADE)) {
293 this._destroyElement(element);
298 $$$1(element).one(Util.TRANSITION_END, function (event) {
299 return _this._destroyElement(element, event);
300 }).emulateTransitionEnd(TRANSITION_DURATION);
303 _proto._destroyElement = function _destroyElement(element) {
304 $$$1(element).detach().trigger(Event.CLOSED).remove();
308 Alert._jQueryInterface = function _jQueryInterface(config) {
309 return this.each(function () {
310 var $element = $$$1(this);
311 var data = $element.data(DATA_KEY);
314 data = new Alert(this);
315 $element.data(DATA_KEY, data);
318 if (config === 'close') {
324 Alert._handleDismiss = function _handleDismiss(alertInstance) {
325 return function (event) {
327 event.preventDefault();
330 alertInstance.close(this);
334 _createClass(Alert, null, [{
336 get: function get() {
343 * ------------------------------------------------------------------------
344 * Data Api implementation
345 * ------------------------------------------------------------------------
349 $$$1(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert()));
351 * ------------------------------------------------------------------------
353 * ------------------------------------------------------------------------
356 $$$1.fn[NAME] = Alert._jQueryInterface;
357 $$$1.fn[NAME].Constructor = Alert;
359 $$$1.fn[NAME].noConflict = function () {
360 $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
361 return Alert._jQueryInterface;
368 * --------------------------------------------------------------------------
369 * Bootstrap (v4.0.0): button.js
370 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
371 * --------------------------------------------------------------------------
374 var Button = function ($$$1) {
376 * ------------------------------------------------------------------------
378 * ------------------------------------------------------------------------
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];
392 DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
393 DATA_TOGGLE: '[data-toggle="buttons"]',
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)
402 * ------------------------------------------------------------------------
404 * ------------------------------------------------------------------------
412 function Button(element) {
413 this._element = element;
417 var _proto = Button.prototype;
420 _proto.toggle = function toggle() {
421 var triggerChangeEvent = true;
422 var addAriaPressed = true;
423 var rootElement = $$$1(this._element).closest(Selector.DATA_TOGGLE)[0];
426 var input = $$$1(this._element).find(Selector.INPUT)[0];
429 if (input.type === 'radio') {
430 if (input.checked && $$$1(this._element).hasClass(ClassName.ACTIVE)) {
431 triggerChangeEvent = false;
433 var activeElement = $$$1(rootElement).find(Selector.ACTIVE)[0];
436 $$$1(activeElement).removeClass(ClassName.ACTIVE);
441 if (triggerChangeEvent) {
442 if (input.hasAttribute('disabled') || rootElement.hasAttribute('disabled') || input.classList.contains('disabled') || rootElement.classList.contains('disabled')) {
446 input.checked = !$$$1(this._element).hasClass(ClassName.ACTIVE);
447 $$$1(input).trigger('change');
451 addAriaPressed = false;
455 if (addAriaPressed) {
456 this._element.setAttribute('aria-pressed', !$$$1(this._element).hasClass(ClassName.ACTIVE));
459 if (triggerChangeEvent) {
460 $$$1(this._element).toggleClass(ClassName.ACTIVE);
464 _proto.dispose = function dispose() {
465 $$$1.removeData(this._element, DATA_KEY);
466 this._element = null;
470 Button._jQueryInterface = function _jQueryInterface(config) {
471 return this.each(function () {
472 var data = $$$1(this).data(DATA_KEY);
475 data = new Button(this);
476 $$$1(this).data(DATA_KEY, data);
479 if (config === 'toggle') {
485 _createClass(Button, null, [{
487 get: function get() {
494 * ------------------------------------------------------------------------
495 * Data Api implementation
496 * ------------------------------------------------------------------------
500 $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
501 event.preventDefault();
502 var button = event.target;
504 if (!$$$1(button).hasClass(ClassName.BUTTON)) {
505 button = $$$1(button).closest(Selector.BUTTON);
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));
514 * ------------------------------------------------------------------------
516 * ------------------------------------------------------------------------
519 $$$1.fn[NAME] = Button._jQueryInterface;
520 $$$1.fn[NAME].Constructor = Button;
522 $$$1.fn[NAME].noConflict = function () {
523 $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
524 return Button._jQueryInterface;
531 * --------------------------------------------------------------------------
532 * Bootstrap (v4.0.0): carousel.js
533 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
534 * --------------------------------------------------------------------------
537 var Carousel = function ($$$1) {
539 * ------------------------------------------------------------------------
541 * ------------------------------------------------------------------------
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
552 var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key
554 var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
564 interval: '(number|boolean)',
566 slide: '(boolean|string)',
567 pause: '(string|boolean)',
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
587 CAROUSEL: 'carousel',
590 RIGHT: 'carousel-item-right',
591 LEFT: 'carousel-item-left',
592 NEXT: 'carousel-item-next',
593 PREV: 'carousel-item-prev',
594 ITEM: 'carousel-item'
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"]'
605 * ------------------------------------------------------------------------
607 * ------------------------------------------------------------------------
615 function Carousel(element, config) {
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];
626 this._addEventListeners();
630 var _proto = Carousel.prototype;
633 _proto.next = function next() {
634 if (!this._isSliding) {
635 this._slide(Direction.NEXT);
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') {
647 _proto.prev = function prev() {
648 if (!this._isSliding) {
649 this._slide(Direction.PREV);
653 _proto.pause = function pause(event) {
655 this._isPaused = true;
658 if ($$$1(this._element).find(Selector.NEXT_PREV)[0] && Util.supportsTransitionEnd()) {
659 Util.triggerTransitionEnd(this._element);
663 clearInterval(this._interval);
664 this._interval = null;
667 _proto.cycle = function cycle(event) {
669 this._isPaused = false;
672 if (this._interval) {
673 clearInterval(this._interval);
674 this._interval = null;
677 if (this._config.interval && !this._isPaused) {
678 this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
682 _proto.to = function to(index) {
685 this._activeElement = $$$1(this._element).find(Selector.ACTIVE_ITEM)[0];
687 var activeIndex = this._getItemIndex(this._activeElement);
689 if (index > this._items.length - 1 || index < 0) {
693 if (this._isSliding) {
694 $$$1(this._element).one(Event.SLID, function () {
695 return _this.to(index);
700 if (activeIndex === index) {
706 var direction = index > activeIndex ? Direction.NEXT : Direction.PREV;
708 this._slide(direction, this._items[index]);
711 _proto.dispose = function dispose() {
712 $$$1(this._element).off(EVENT_KEY);
713 $$$1.removeData(this._element, DATA_KEY);
716 this._element = null;
717 this._interval = null;
718 this._isPaused = null;
719 this._isSliding = null;
720 this._activeElement = null;
721 this._indicatorsElement = null;
725 _proto._getConfig = function _getConfig(config) {
726 config = _extends({}, Default, config);
727 Util.typeCheckConfig(NAME, config, DefaultType);
731 _proto._addEventListeners = function _addEventListeners() {
734 if (this._config.keyboard) {
735 $$$1(this._element).on(Event.KEYDOWN, function (event) {
736 return _this2._keydown(event);
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);
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 () {
758 if (_this2.touchTimeout) {
759 clearTimeout(_this2.touchTimeout);
762 _this2.touchTimeout = setTimeout(function (event) {
763 return _this2.cycle(event);
764 }, TOUCHEVENT_COMPAT_WAIT + _this2._config.interval);
770 _proto._keydown = function _keydown(event) {
771 if (/input|textarea/i.test(event.target.tagName)) {
775 switch (event.which) {
776 case ARROW_LEFT_KEYCODE:
777 event.preventDefault();
781 case ARROW_RIGHT_KEYCODE:
782 event.preventDefault();
790 _proto._getItemIndex = function _getItemIndex(element) {
791 this._items = $$$1.makeArray($$$1(element).parent().find(Selector.ITEM));
792 return this._items.indexOf(element);
795 _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
796 var isNextDirection = direction === Direction.NEXT;
797 var isPrevDirection = direction === Direction.PREV;
799 var activeIndex = this._getItemIndex(activeElement);
801 var lastItemIndex = this._items.length - 1;
802 var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex;
804 if (isGoingToWrap && !this._config.wrap) {
805 return activeElement;
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];
813 _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
814 var targetIndex = this._getItemIndex(relatedTarget);
816 var fromIndex = this._getItemIndex($$$1(this._element).find(Selector.ACTIVE_ITEM)[0]);
818 var slideEvent = $$$1.Event(Event.SLIDE, {
819 relatedTarget: relatedTarget,
820 direction: eventDirectionName,
824 $$$1(this._element).trigger(slideEvent);
828 _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
829 if (this._indicatorsElement) {
830 $$$1(this._indicatorsElement).find(Selector.ACTIVE).removeClass(ClassName.ACTIVE);
832 var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)];
835 $$$1(nextIndicator).addClass(ClassName.ACTIVE);
840 _proto._slide = function _slide(direction, element) {
843 var activeElement = $$$1(this._element).find(Selector.ACTIVE_ITEM)[0];
845 var activeElementIndex = this._getItemIndex(activeElement);
847 var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement);
849 var nextElementIndex = this._getItemIndex(nextElement);
851 var isCycling = Boolean(this._interval);
852 var directionalClassName;
854 var eventDirectionName;
856 if (direction === Direction.NEXT) {
857 directionalClassName = ClassName.LEFT;
858 orderClassName = ClassName.NEXT;
859 eventDirectionName = Direction.LEFT;
861 directionalClassName = ClassName.RIGHT;
862 orderClassName = ClassName.PREV;
863 eventDirectionName = Direction.RIGHT;
866 if (nextElement && $$$1(nextElement).hasClass(ClassName.ACTIVE)) {
867 this._isSliding = false;
871 var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
873 if (slideEvent.isDefaultPrevented()) {
877 if (!activeElement || !nextElement) {
878 // Some weirdness is happening, so we bail
882 this._isSliding = true;
888 this._setActiveIndicatorElement(nextElement);
890 var slidEvent = $$$1.Event(Event.SLID, {
891 relatedTarget: nextElement,
892 direction: eventDirectionName,
893 from: activeElementIndex,
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);
909 }).emulateTransitionEnd(TRANSITION_DURATION);
911 $$$1(activeElement).removeClass(ClassName.ACTIVE);
912 $$$1(nextElement).addClass(ClassName.ACTIVE);
913 this._isSliding = false;
914 $$$1(this._element).trigger(slidEvent);
923 Carousel._jQueryInterface = function _jQueryInterface(config) {
924 return this.each(function () {
925 var data = $$$1(this).data(DATA_KEY);
927 var _config = _extends({}, Default, $$$1(this).data());
929 if (typeof config === 'object') {
930 _config = _extends({}, _config, config);
933 var action = typeof config === 'string' ? config : _config.slide;
936 data = new Carousel(this, _config);
937 $$$1(this).data(DATA_KEY, data);
940 if (typeof config === 'number') {
942 } else if (typeof action === 'string') {
943 if (typeof data[action] === 'undefined') {
944 throw new TypeError("No method named \"" + action + "\"");
948 } else if (_config.interval) {
955 Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
956 var selector = Util.getSelectorFromElement(this);
962 var target = $$$1(selector)[0];
964 if (!target || !$$$1(target).hasClass(ClassName.CAROUSEL)) {
968 var config = _extends({}, $$$1(target).data(), $$$1(this).data());
969 var slideIndex = this.getAttribute('data-slide-to');
972 config.interval = false;
975 Carousel._jQueryInterface.call($$$1(target), config);
978 $$$1(target).data(DATA_KEY).to(slideIndex);
981 event.preventDefault();
984 _createClass(Carousel, null, [{
986 get: function get() {
991 get: function get() {
998 * ------------------------------------------------------------------------
999 * Data Api implementation
1000 * ------------------------------------------------------------------------
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);
1009 Carousel._jQueryInterface.call($carousel, $carousel.data());
1013 * ------------------------------------------------------------------------
1015 * ------------------------------------------------------------------------
1018 $$$1.fn[NAME] = Carousel._jQueryInterface;
1019 $$$1.fn[NAME].Constructor = Carousel;
1021 $$$1.fn[NAME].noConflict = function () {
1022 $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
1023 return Carousel._jQueryInterface;
1030 * --------------------------------------------------------------------------
1031 * Bootstrap (v4.0.0): collapse.js
1032 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1033 * --------------------------------------------------------------------------
1036 var Collapse = function ($$$1) {
1038 * ------------------------------------------------------------------------
1040 * ------------------------------------------------------------------------
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;
1055 parent: '(string|element)'
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
1066 COLLAPSE: 'collapse',
1067 COLLAPSING: 'collapsing',
1068 COLLAPSED: 'collapsed'
1075 ACTIVES: '.show, .collapsing',
1076 DATA_TOGGLE: '[data-toggle="collapse"]'
1078 * ------------------------------------------------------------------------
1080 * ------------------------------------------------------------------------
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);
1095 for (var i = 0; i < tabToggles.length; i++) {
1096 var elem = tabToggles[i];
1097 var selector = Util.getSelectorFromElement(elem);
1099 if (selector !== null && $$$1(selector).filter(element).length > 0) {
1100 this._selector = selector;
1102 this._triggerArray.push(elem);
1106 this._parent = this._config.parent ? this._getParent() : null;
1108 if (!this._config.parent) {
1109 this._addAriaAndCollapsedClass(this._element, this._triggerArray);
1112 if (this._config.toggle) {
1118 var _proto = Collapse.prototype;
1121 _proto.toggle = function toggle() {
1122 if ($$$1(this._element).hasClass(ClassName.SHOW)) {
1129 _proto.show = function show() {
1132 if (this._isTransitioning || $$$1(this._element).hasClass(ClassName.SHOW)) {
1140 actives = $$$1.makeArray($$$1(this._parent).find(Selector.ACTIVES).filter("[data-parent=\"" + this._config.parent + "\"]"));
1142 if (actives.length === 0) {
1148 activesData = $$$1(actives).not(this._selector).data(DATA_KEY);
1150 if (activesData && activesData._isTransitioning) {
1155 var startEvent = $$$1.Event(Event.SHOW);
1156 $$$1(this._element).trigger(startEvent);
1158 if (startEvent.isDefaultPrevented()) {
1163 Collapse._jQueryInterface.call($$$1(actives).not(this._selector), 'hide');
1166 $$$1(actives).data(DATA_KEY, null);
1170 var dimension = this._getDimension();
1172 $$$1(this._element).removeClass(ClassName.COLLAPSE).addClass(ClassName.COLLAPSING);
1173 this._element.style[dimension] = 0;
1175 if (this._triggerArray.length > 0) {
1176 $$$1(this._triggerArray).removeClass(ClassName.COLLAPSED).attr('aria-expanded', true);
1179 this.setTransitioning(true);
1181 var complete = function complete() {
1182 $$$1(_this._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).addClass(ClassName.SHOW);
1183 _this._element.style[dimension] = '';
1185 _this.setTransitioning(false);
1187 $$$1(_this._element).trigger(Event.SHOWN);
1190 if (!Util.supportsTransitionEnd()) {
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";
1201 _proto.hide = function hide() {
1204 if (this._isTransitioning || !$$$1(this._element).hasClass(ClassName.SHOW)) {
1208 var startEvent = $$$1.Event(Event.HIDE);
1209 $$$1(this._element).trigger(startEvent);
1211 if (startEvent.isDefaultPrevented()) {
1215 var dimension = this._getDimension();
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);
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);
1226 if (selector !== null) {
1227 var $elem = $$$1(selector);
1229 if (!$elem.hasClass(ClassName.SHOW)) {
1230 $$$1(trigger).addClass(ClassName.COLLAPSED).attr('aria-expanded', false);
1236 this.setTransitioning(true);
1238 var complete = function complete() {
1239 _this2.setTransitioning(false);
1241 $$$1(_this2._element).removeClass(ClassName.COLLAPSING).addClass(ClassName.COLLAPSE).trigger(Event.HIDDEN);
1244 this._element.style[dimension] = '';
1246 if (!Util.supportsTransitionEnd()) {
1251 $$$1(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
1254 _proto.setTransitioning = function setTransitioning(isTransitioning) {
1255 this._isTransitioning = isTransitioning;
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;
1268 _proto._getConfig = function _getConfig(config) {
1269 config = _extends({}, Default, config);
1270 config.toggle = Boolean(config.toggle); // Coerce string values
1272 Util.typeCheckConfig(NAME, config, DefaultType);
1276 _proto._getDimension = function _getDimension() {
1277 var hasWidth = $$$1(this._element).hasClass(Dimension.WIDTH);
1278 return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT;
1281 _proto._getParent = function _getParent() {
1286 if (Util.isElement(this._config.parent)) {
1287 parent = this._config.parent; // It's a jQuery object
1289 if (typeof this._config.parent.jquery !== 'undefined') {
1290 parent = this._config.parent[0];
1293 parent = $$$1(this._config.parent)[0];
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]);
1303 _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
1305 var isOpen = $$$1(element).hasClass(ClassName.SHOW);
1307 if (triggerArray.length > 0) {
1308 $$$1(triggerArray).toggleClass(ClassName.COLLAPSED, !isOpen).attr('aria-expanded', isOpen);
1314 Collapse._getTargetFromElement = function _getTargetFromElement(element) {
1315 var selector = Util.getSelectorFromElement(element);
1316 return selector ? $$$1(selector)[0] : null;
1319 Collapse._jQueryInterface = function _jQueryInterface(config) {
1320 return this.each(function () {
1321 var $this = $$$1(this);
1322 var data = $this.data(DATA_KEY);
1324 var _config = _extends({}, Default, $this.data(), typeof config === 'object' && config);
1326 if (!data && _config.toggle && /show|hide/.test(config)) {
1327 _config.toggle = false;
1331 data = new Collapse(this, _config);
1332 $this.data(DATA_KEY, data);
1335 if (typeof config === 'string') {
1336 if (typeof data[config] === 'undefined') {
1337 throw new TypeError("No method named \"" + config + "\"");
1345 _createClass(Collapse, null, [{
1347 get: function get() {
1352 get: function get() {
1359 * ------------------------------------------------------------------------
1360 * Data Api implementation
1361 * ------------------------------------------------------------------------
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();
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();
1378 Collapse._jQueryInterface.call($target, config);
1382 * ------------------------------------------------------------------------
1384 * ------------------------------------------------------------------------
1387 $$$1.fn[NAME] = Collapse._jQueryInterface;
1388 $$$1.fn[NAME].Constructor = Collapse;
1390 $$$1.fn[NAME].noConflict = function () {
1391 $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
1392 return Collapse._jQueryInterface;
1399 * --------------------------------------------------------------------------
1400 * Bootstrap (v4.0.0): dropdown.js
1401 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1402 * --------------------------------------------------------------------------
1405 var Dropdown = function ($$$1) {
1407 * ------------------------------------------------------------------------
1409 * ------------------------------------------------------------------------
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
1419 var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key
1421 var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key
1423 var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key
1425 var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key
1427 var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse)
1429 var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE);
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
1441 DISABLED: 'disabled',
1444 DROPRIGHT: 'dropright',
1445 DROPLEFT: 'dropleft',
1446 MENURIGHT: 'dropdown-menu-right',
1447 MENULEFT: 'dropdown-menu-left',
1448 POSITION_STATIC: 'position-static'
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)'
1457 var AttachmentMap = {
1460 BOTTOM: 'bottom-start',
1461 BOTTOMEND: 'bottom-end',
1462 RIGHT: 'right-start',
1463 RIGHTEND: 'right-end',
1470 boundary: 'scrollParent'
1473 offset: '(number|string|function)',
1475 boundary: '(string|element)'
1477 * ------------------------------------------------------------------------
1479 * ------------------------------------------------------------------------
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();
1494 this._addEventListeners();
1498 var _proto = Dropdown.prototype;
1501 _proto.toggle = function toggle() {
1502 if (this._element.disabled || $$$1(this._element).hasClass(ClassName.DISABLED)) {
1506 var parent = Dropdown._getParentFromElement(this._element);
1508 var isActive = $$$1(this._menu).hasClass(ClassName.SHOW);
1510 Dropdown._clearMenus();
1516 var relatedTarget = {
1517 relatedTarget: this._element
1519 var showEvent = $$$1.Event(Event.SHOW, relatedTarget);
1520 $$$1(parent).trigger(showEvent);
1522 if (showEvent.isDefaultPrevented()) {
1524 } // Disable totally Popper.js for Dropdown in Navbar
1527 if (!this._inNavbar) {
1529 * Check for Popper dependency
1530 * Popper - https://popper.js.org
1532 if (typeof Popper === 'undefined') {
1533 throw new TypeError('Bootstrap dropdown require Popper.js (https://popper.js.org)');
1536 var element = this._element; // For dropup with alignment we use the parent as popper container
1538 if ($$$1(parent).hasClass(ClassName.DROPUP)) {
1539 if ($$$1(this._menu).hasClass(ClassName.MENULEFT) || $$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
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
1547 if (this._config.boundary !== 'scrollParent') {
1548 $$$1(parent).addClass(ClassName.POSITION_STATIC);
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
1558 if ('ontouchstart' in document.documentElement && $$$1(parent).closest(Selector.NAVBAR_NAV).length === 0) {
1559 $$$1('body').children().on('mouseover', null, $$$1.noop);
1562 this._element.focus();
1564 this._element.setAttribute('aria-expanded', true);
1566 $$$1(this._menu).toggleClass(ClassName.SHOW);
1567 $$$1(parent).toggleClass(ClassName.SHOW).trigger($$$1.Event(Event.SHOWN, relatedTarget));
1570 _proto.dispose = function dispose() {
1571 $$$1.removeData(this._element, DATA_KEY);
1572 $$$1(this._element).off(EVENT_KEY);
1573 this._element = null;
1576 if (this._popper !== null) {
1577 this._popper.destroy();
1579 this._popper = null;
1583 _proto.update = function update() {
1584 this._inNavbar = this._detectNavbar();
1586 if (this._popper !== null) {
1587 this._popper.scheduleUpdate();
1592 _proto._addEventListeners = function _addEventListeners() {
1595 $$$1(this._element).on(Event.CLICK, function (event) {
1596 event.preventDefault();
1597 event.stopPropagation();
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);
1609 _proto._getMenuElement = function _getMenuElement() {
1611 var parent = Dropdown._getParentFromElement(this._element);
1613 this._menu = $$$1(parent).find(Selector.MENU)[0];
1619 _proto._getPlacement = function _getPlacement() {
1620 var $parentDropdown = $$$1(this._element).parent();
1621 var placement = AttachmentMap.BOTTOM; // Handle dropup
1623 if ($parentDropdown.hasClass(ClassName.DROPUP)) {
1624 placement = AttachmentMap.TOP;
1626 if ($$$1(this._menu).hasClass(ClassName.MENURIGHT)) {
1627 placement = AttachmentMap.TOPEND;
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;
1640 _proto._detectNavbar = function _detectNavbar() {
1641 return $$$1(this._element).closest('.navbar').length > 0;
1644 _proto._getPopperConfig = function _getPopperConfig() {
1647 var offsetConf = {};
1649 if (typeof this._config.offset === 'function') {
1650 offsetConf.fn = function (data) {
1651 data.offsets = _extends({}, data.offsets, _this2._config.offset(data.offsets) || {});
1655 offsetConf.offset = this._config.offset;
1658 var popperConfig = {
1659 placement: this._getPlacement(),
1663 enabled: this._config.flip
1666 boundariesElement: this._config.boundary
1670 return popperConfig;
1674 Dropdown._jQueryInterface = function _jQueryInterface(config) {
1675 return this.each(function () {
1676 var data = $$$1(this).data(DATA_KEY);
1678 var _config = typeof config === 'object' ? config : null;
1681 data = new Dropdown(this, _config);
1682 $$$1(this).data(DATA_KEY, data);
1685 if (typeof config === 'string') {
1686 if (typeof data[config] === 'undefined') {
1687 throw new TypeError("No method named \"" + config + "\"");
1695 Dropdown._clearMenus = function _clearMenus(event) {
1696 if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) {
1700 var toggles = $$$1.makeArray($$$1(Selector.DATA_TOGGLE));
1702 for (var i = 0; i < toggles.length; i++) {
1703 var parent = Dropdown._getParentFromElement(toggles[i]);
1705 var context = $$$1(toggles[i]).data(DATA_KEY);
1706 var relatedTarget = {
1707 relatedTarget: toggles[i]
1714 var dropdownMenu = context._menu;
1716 if (!$$$1(parent).hasClass(ClassName.SHOW)) {
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)) {
1724 var hideEvent = $$$1.Event(Event.HIDE, relatedTarget);
1725 $$$1(parent).trigger(hideEvent);
1727 if (hideEvent.isDefaultPrevented()) {
1729 } // If this is a touch-enabled device we remove the extra
1730 // empty mouseover listeners we added for iOS support
1733 if ('ontouchstart' in document.documentElement) {
1734 $$$1('body').children().off('mouseover', null, $$$1.noop);
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));
1743 Dropdown._getParentFromElement = function _getParentFromElement(element) {
1745 var selector = Util.getSelectorFromElement(element);
1748 parent = $$$1(selector)[0];
1751 return parent || element.parentNode;
1752 }; // eslint-disable-next-line complexity
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)) {
1767 event.preventDefault();
1768 event.stopPropagation();
1770 if (this.disabled || $$$1(this).hasClass(ClassName.DISABLED)) {
1774 var parent = Dropdown._getParentFromElement(this);
1776 var isActive = $$$1(parent).hasClass(ClassName.SHOW);
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');
1784 $$$1(this).trigger('click');
1788 var items = $$$1(parent).find(Selector.VISIBLE_ITEMS).get();
1790 if (items.length === 0) {
1794 var index = items.indexOf(event.target);
1796 if (event.which === ARROW_UP_KEYCODE && index > 0) {
1801 if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) {
1810 items[index].focus();
1813 _createClass(Dropdown, null, [{
1815 get: function get() {
1820 get: function get() {
1825 get: function get() {
1832 * ------------------------------------------------------------------------
1833 * Data Api implementation
1834 * ------------------------------------------------------------------------
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();
1842 Dropdown._jQueryInterface.call($$$1(this), 'toggle');
1843 }).on(Event.CLICK_DATA_API, Selector.FORM_CHILD, function (e) {
1844 e.stopPropagation();
1847 * ------------------------------------------------------------------------
1849 * ------------------------------------------------------------------------
1852 $$$1.fn[NAME] = Dropdown._jQueryInterface;
1853 $$$1.fn[NAME].Constructor = Dropdown;
1855 $$$1.fn[NAME].noConflict = function () {
1856 $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
1857 return Dropdown._jQueryInterface;
1864 * --------------------------------------------------------------------------
1865 * Bootstrap (v4.0.0): modal.js
1866 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1867 * --------------------------------------------------------------------------
1870 var Modal = function ($$$1) {
1872 * ------------------------------------------------------------------------
1874 * ------------------------------------------------------------------------
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
1893 backdrop: '(boolean|string)',
1894 keyboard: 'boolean',
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
1912 SCROLLBAR_MEASURER: 'modal-scrollbar-measure',
1913 BACKDROP: 'modal-backdrop',
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'
1926 * ------------------------------------------------------------------------
1928 * ------------------------------------------------------------------------
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;
1949 var _proto = Modal.prototype;
1952 _proto.toggle = function toggle(relatedTarget) {
1953 return this._isShown ? this.hide() : this.show(relatedTarget);
1956 _proto.show = function show(relatedTarget) {
1959 if (this._isTransitioning || this._isShown) {
1963 if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE)) {
1964 this._isTransitioning = true;
1967 var showEvent = $$$1.Event(Event.SHOW, {
1968 relatedTarget: relatedTarget
1970 $$$1(this._element).trigger(showEvent);
1972 if (this._isShown || showEvent.isDefaultPrevented()) {
1976 this._isShown = true;
1978 this._checkScrollbar();
1980 this._setScrollbar();
1982 this._adjustDialog();
1984 $$$1(document.body).addClass(ClassName.OPEN);
1986 this._setEscapeEvent();
1988 this._setResizeEvent();
1990 $$$1(this._element).on(Event.CLICK_DISMISS, Selector.DATA_DISMISS, function (event) {
1991 return _this.hide(event);
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;
2001 this._showBackdrop(function () {
2002 return _this._showElement(relatedTarget);
2006 _proto.hide = function hide(event) {
2010 event.preventDefault();
2013 if (this._isTransitioning || !this._isShown) {
2017 var hideEvent = $$$1.Event(Event.HIDE);
2018 $$$1(this._element).trigger(hideEvent);
2020 if (!this._isShown || hideEvent.isDefaultPrevented()) {
2024 this._isShown = false;
2025 var transition = Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE);
2028 this._isTransitioning = true;
2031 this._setEscapeEvent();
2033 this._setResizeEvent();
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);
2041 $$$1(this._element).one(Util.TRANSITION_END, function (event) {
2042 return _this2._hideModal(event);
2043 }).emulateTransitionEnd(TRANSITION_DURATION);
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;
2062 _proto.handleUpdate = function handleUpdate() {
2063 this._adjustDialog();
2067 _proto._getConfig = function _getConfig(config) {
2068 config = _extends({}, Default, config);
2069 Util.typeCheckConfig(NAME, config, DefaultType);
2073 _proto._showElement = function _showElement(relatedTarget) {
2076 var transition = Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE);
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);
2083 this._element.style.display = 'block';
2085 this._element.removeAttribute('aria-hidden');
2087 this._element.scrollTop = 0;
2090 Util.reflow(this._element);
2093 $$$1(this._element).addClass(ClassName.SHOW);
2095 if (this._config.focus) {
2096 this._enforceFocus();
2099 var shownEvent = $$$1.Event(Event.SHOWN, {
2100 relatedTarget: relatedTarget
2103 var transitionComplete = function transitionComplete() {
2104 if (_this3._config.focus) {
2105 _this3._element.focus();
2108 _this3._isTransitioning = false;
2109 $$$1(_this3._element).trigger(shownEvent);
2113 $$$1(this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(TRANSITION_DURATION);
2115 transitionComplete();
2119 _proto._enforceFocus = function _enforceFocus() {
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();
2130 _proto._setEscapeEvent = function _setEscapeEvent() {
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();
2141 } else if (!this._isShown) {
2142 $$$1(this._element).off(Event.KEYDOWN_DISMISS);
2146 _proto._setResizeEvent = function _setResizeEvent() {
2149 if (this._isShown) {
2150 $$$1(window).on(Event.RESIZE, function (event) {
2151 return _this6.handleUpdate(event);
2154 $$$1(window).off(Event.RESIZE);
2158 _proto._hideModal = function _hideModal() {
2161 this._element.style.display = 'none';
2163 this._element.setAttribute('aria-hidden', true);
2165 this._isTransitioning = false;
2167 this._showBackdrop(function () {
2168 $$$1(document.body).removeClass(ClassName.OPEN);
2170 _this7._resetAdjustments();
2172 _this7._resetScrollbar();
2174 $$$1(_this7._element).trigger(Event.HIDDEN);
2178 _proto._removeBackdrop = function _removeBackdrop() {
2179 if (this._backdrop) {
2180 $$$1(this._backdrop).remove();
2181 this._backdrop = null;
2185 _proto._showBackdrop = function _showBackdrop(callback) {
2188 var animate = $$$1(this._element).hasClass(ClassName.FADE) ? ClassName.FADE : '';
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;
2196 $$$1(this._backdrop).addClass(animate);
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;
2206 if (event.target !== event.currentTarget) {
2210 if (_this8._config.backdrop === 'static') {
2211 _this8._element.focus();
2218 Util.reflow(this._backdrop);
2221 $$$1(this._backdrop).addClass(ClassName.SHOW);
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);
2236 var callbackRemove = function callbackRemove() {
2237 _this8._removeBackdrop();
2244 if (Util.supportsTransitionEnd() && $$$1(this._element).hasClass(ClassName.FADE)) {
2245 $$$1(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(BACKDROP_TRANSITION_DURATION);
2249 } else if (callback) {
2252 }; // ----------------------------------------------------------------------
2253 // the following methods are used to handle overflowing modals
2254 // todo (fat): these should probably be refactored out of modal.js
2255 // ----------------------------------------------------------------------
2258 _proto._adjustDialog = function _adjustDialog() {
2259 var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
2261 if (!this._isBodyOverflowing && isModalOverflowing) {
2262 this._element.style.paddingLeft = this._scrollbarWidth + "px";
2265 if (this._isBodyOverflowing && !isModalOverflowing) {
2266 this._element.style.paddingRight = this._scrollbarWidth + "px";
2270 _proto._resetAdjustments = function _resetAdjustments() {
2271 this._element.style.paddingLeft = '';
2272 this._element.style.paddingRight = '';
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();
2281 _proto._setScrollbar = function _setScrollbar() {
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
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
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
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");
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');
2317 if (typeof padding !== 'undefined') {
2318 $$$1(element).css('padding-right', padding).removeData('padding-right');
2320 }); // Restore sticky content and navbar-toggler margin
2322 $$$1(Selector.STICKY_CONTENT + ", " + Selector.NAVBAR_TOGGLER).each(function (index, element) {
2323 var margin = $$$1(element).data('margin-right');
2325 if (typeof margin !== 'undefined') {
2326 $$$1(element).css('margin-right', margin).removeData('margin-right');
2328 }); // Restore body padding
2330 var padding = $$$1('body').data('padding-right');
2332 if (typeof padding !== 'undefined') {
2333 $$$1('body').css('padding-right', padding).removeData('padding-right');
2337 _proto._getScrollbarWidth = function _getScrollbarWidth() {
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;
2348 Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) {
2349 return this.each(function () {
2350 var data = $$$1(this).data(DATA_KEY);
2352 var _config = _extends({}, Modal.Default, $$$1(this).data(), typeof config === 'object' && config);
2355 data = new Modal(this, _config);
2356 $$$1(this).data(DATA_KEY, data);
2359 if (typeof config === 'string') {
2360 if (typeof data[config] === 'undefined') {
2361 throw new TypeError("No method named \"" + config + "\"");
2364 data[config](relatedTarget);
2365 } else if (_config.show) {
2366 data.show(relatedTarget);
2371 _createClass(Modal, null, [{
2373 get: function get() {
2378 get: function get() {
2385 * ------------------------------------------------------------------------
2386 * Data Api implementation
2387 * ------------------------------------------------------------------------
2391 $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
2395 var selector = Util.getSelectorFromElement(this);
2398 target = $$$1(selector)[0];
2401 var config = $$$1(target).data(DATA_KEY) ? 'toggle' : _extends({}, $$$1(target).data(), $$$1(this).data());
2403 if (this.tagName === 'A' || this.tagName === 'AREA') {
2404 event.preventDefault();
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
2413 $target.one(Event.HIDDEN, function () {
2414 if ($$$1(_this10).is(':visible')) {
2420 Modal._jQueryInterface.call($$$1(target), config, this);
2423 * ------------------------------------------------------------------------
2425 * ------------------------------------------------------------------------
2428 $$$1.fn[NAME] = Modal._jQueryInterface;
2429 $$$1.fn[NAME].Constructor = Modal;
2431 $$$1.fn[NAME].noConflict = function () {
2432 $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
2433 return Modal._jQueryInterface;
2440 * --------------------------------------------------------------------------
2441 * Bootstrap (v4.0.0): tooltip.js
2442 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
2443 * --------------------------------------------------------------------------
2446 var Tooltip = function ($$$1) {
2448 * ------------------------------------------------------------------------
2450 * ------------------------------------------------------------------------
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');
2461 animation: 'boolean',
2463 title: '(string|element|function)',
2465 delay: '(number|object)',
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)'
2474 var AttachmentMap = {
2483 template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>',
2484 trigger: 'hover focus',
2492 fallbackPlacement: 'flip',
2493 boundary: 'scrollParent'
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
2516 TOOLTIP: '.tooltip',
2517 TOOLTIP_INNER: '.tooltip-inner',
2526 * ------------------------------------------------------------------------
2528 * ------------------------------------------------------------------------
2536 function Tooltip(element, config) {
2538 * Check for Popper dependency
2539 * Popper - https://popper.js.org
2541 if (typeof Popper === 'undefined') {
2542 throw new TypeError('Bootstrap tooltips require Popper.js (https://popper.js.org)');
2546 this._isEnabled = true;
2548 this._hoverState = '';
2549 this._activeTrigger = {};
2550 this._popper = null; // Protected
2552 this.element = element;
2553 this.config = this._getConfig(config);
2556 this._setListeners();
2560 var _proto = Tooltip.prototype;
2563 _proto.enable = function enable() {
2564 this._isEnabled = true;
2567 _proto.disable = function disable() {
2568 this._isEnabled = false;
2571 _proto.toggleEnabled = function toggleEnabled() {
2572 this._isEnabled = !this._isEnabled;
2575 _proto.toggle = function toggle(event) {
2576 if (!this._isEnabled) {
2581 var dataKey = this.constructor.DATA_KEY;
2582 var context = $$$1(event.currentTarget).data(dataKey);
2585 context = new this.constructor(event.currentTarget, this._getDelegateConfig());
2586 $$$1(event.currentTarget).data(dataKey, context);
2589 context._activeTrigger.click = !context._activeTrigger.click;
2591 if (context._isWithActiveTrigger()) {
2592 context._enter(null, context);
2594 context._leave(null, context);
2597 if ($$$1(this.getTipElement()).hasClass(ClassName.SHOW)) {
2598 this._leave(null, this);
2603 this._enter(null, this);
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');
2614 $$$1(this.tip).remove();
2617 this._isEnabled = null;
2618 this._timeout = null;
2619 this._hoverState = null;
2620 this._activeTrigger = null;
2622 if (this._popper !== null) {
2623 this._popper.destroy();
2626 this._popper = null;
2627 this.element = null;
2632 _proto.show = function show() {
2635 if ($$$1(this.element).css('display') === 'none') {
2636 throw new Error('Please use show on visible elements');
2639 var showEvent = $$$1.Event(this.constructor.Event.SHOW);
2641 if (this.isWithContent() && this._isEnabled) {
2642 $$$1(this.element).trigger(showEvent);
2643 var isInTheDom = $$$1.contains(this.element.ownerDocument.documentElement, this.element);
2645 if (showEvent.isDefaultPrevented() || !isInTheDom) {
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);
2655 if (this.config.animation) {
2656 $$$1(tip).addClass(ClassName.FADE);
2659 var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement;
2661 var attachment = this._getAttachment(placement);
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);
2667 if (!$$$1.contains(this.element.ownerDocument.documentElement, this.tip)) {
2668 $$$1(tip).appendTo(container);
2671 $$$1(this.element).trigger(this.constructor.Event.INSERTED);
2672 this._popper = new Popper(this.element, tip, {
2673 placement: attachment,
2676 offset: this.config.offset
2679 behavior: this.config.fallbackPlacement
2682 element: Selector.ARROW
2685 boundariesElement: this.config.boundary
2688 onCreate: function onCreate(data) {
2689 if (data.originalPlacement !== data.placement) {
2690 _this._handlePopperPlacementChange(data);
2693 onUpdate: function onUpdate(data) {
2694 _this._handlePopperPlacementChange(data);
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
2702 if ('ontouchstart' in document.documentElement) {
2703 $$$1('body').children().on('mouseover', null, $$$1.noop);
2706 var complete = function complete() {
2707 if (_this.config.animation) {
2708 _this._fixTransition();
2711 var prevHoverState = _this._hoverState;
2712 _this._hoverState = null;
2713 $$$1(_this.element).trigger(_this.constructor.Event.SHOWN);
2715 if (prevHoverState === HoverState.OUT) {
2716 _this._leave(null, _this);
2720 if (Util.supportsTransitionEnd() && $$$1(this.tip).hasClass(ClassName.FADE)) {
2721 $$$1(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(Tooltip._TRANSITION_DURATION);
2728 _proto.hide = function hide(callback) {
2731 var tip = this.getTipElement();
2732 var hideEvent = $$$1.Event(this.constructor.Event.HIDE);
2734 var complete = function complete() {
2735 if (_this2._hoverState !== HoverState.SHOW && tip.parentNode) {
2736 tip.parentNode.removeChild(tip);
2739 _this2._cleanTipClass();
2741 _this2.element.removeAttribute('aria-describedby');
2743 $$$1(_this2.element).trigger(_this2.constructor.Event.HIDDEN);
2745 if (_this2._popper !== null) {
2746 _this2._popper.destroy();
2754 $$$1(this.element).trigger(hideEvent);
2756 if (hideEvent.isDefaultPrevented()) {
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
2763 if ('ontouchstart' in document.documentElement) {
2764 $$$1('body').children().off('mouseover', null, $$$1.noop);
2767 this._activeTrigger[Trigger.CLICK] = false;
2768 this._activeTrigger[Trigger.FOCUS] = false;
2769 this._activeTrigger[Trigger.HOVER] = false;
2771 if (Util.supportsTransitionEnd() && $$$1(this.tip).hasClass(ClassName.FADE)) {
2772 $$$1(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
2777 this._hoverState = '';
2780 _proto.update = function update() {
2781 if (this._popper !== null) {
2782 this._popper.scheduleUpdate();
2787 _proto.isWithContent = function isWithContent() {
2788 return Boolean(this.getTitle());
2791 _proto.addAttachmentClass = function addAttachmentClass(attachment) {
2792 $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
2795 _proto.getTipElement = function getTipElement() {
2796 this.tip = this.tip || $$$1(this.config.template)[0];
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);
2806 _proto.setElementContent = function setElementContent($element, content) {
2807 var html = this.config.html;
2809 if (typeof content === 'object' && (content.nodeType || content.jquery)) {
2810 // Content is a DOM node or a jQuery
2812 if (!$$$1(content).parent().is($element)) {
2813 $element.empty().append(content);
2816 $element.text($$$1(content).text());
2819 $element[html ? 'html' : 'text'](content);
2823 _proto.getTitle = function getTitle() {
2824 var title = this.element.getAttribute('data-original-title');
2827 title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title;
2834 _proto._getAttachment = function _getAttachment(placement) {
2835 return AttachmentMap[placement.toUpperCase()];
2838 _proto._setListeners = function _setListeners() {
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);
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);
2857 $$$1(_this3.element).closest('.modal').on('hide.bs.modal', function () {
2858 return _this3.hide();
2862 if (this.config.selector) {
2863 this.config = _extends({}, this.config, {
2872 _proto._fixTitle = function _fixTitle() {
2873 var titleType = typeof this.element.getAttribute('data-original-title');
2875 if (this.element.getAttribute('title') || titleType !== 'string') {
2876 this.element.setAttribute('data-original-title', this.element.getAttribute('title') || '');
2877 this.element.setAttribute('title', '');
2881 _proto._enter = function _enter(event, context) {
2882 var dataKey = this.constructor.DATA_KEY;
2883 context = context || $$$1(event.currentTarget).data(dataKey);
2886 context = new this.constructor(event.currentTarget, this._getDelegateConfig());
2887 $$$1(event.currentTarget).data(dataKey, context);
2891 context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true;
2894 if ($$$1(context.getTipElement()).hasClass(ClassName.SHOW) || context._hoverState === HoverState.SHOW) {
2895 context._hoverState = HoverState.SHOW;
2899 clearTimeout(context._timeout);
2900 context._hoverState = HoverState.SHOW;
2902 if (!context.config.delay || !context.config.delay.show) {
2907 context._timeout = setTimeout(function () {
2908 if (context._hoverState === HoverState.SHOW) {
2911 }, context.config.delay.show);
2914 _proto._leave = function _leave(event, context) {
2915 var dataKey = this.constructor.DATA_KEY;
2916 context = context || $$$1(event.currentTarget).data(dataKey);
2919 context = new this.constructor(event.currentTarget, this._getDelegateConfig());
2920 $$$1(event.currentTarget).data(dataKey, context);
2924 context._activeTrigger[event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER] = false;
2927 if (context._isWithActiveTrigger()) {
2931 clearTimeout(context._timeout);
2932 context._hoverState = HoverState.OUT;
2934 if (!context.config.delay || !context.config.delay.hide) {
2939 context._timeout = setTimeout(function () {
2940 if (context._hoverState === HoverState.OUT) {
2943 }, context.config.delay.hide);
2946 _proto._isWithActiveTrigger = function _isWithActiveTrigger() {
2947 for (var trigger in this._activeTrigger) {
2948 if (this._activeTrigger[trigger]) {
2956 _proto._getConfig = function _getConfig(config) {
2957 config = _extends({}, this.constructor.Default, $$$1(this.element).data(), config);
2959 if (typeof config.delay === 'number') {
2966 if (typeof config.title === 'number') {
2967 config.title = config.title.toString();
2970 if (typeof config.content === 'number') {
2971 config.content = config.content.toString();
2974 Util.typeCheckConfig(NAME, config, this.constructor.DefaultType);
2978 _proto._getDelegateConfig = function _getDelegateConfig() {
2982 for (var key in this.config) {
2983 if (this.constructor.Default[key] !== this.config[key]) {
2984 config[key] = this.config[key];
2992 _proto._cleanTipClass = function _cleanTipClass() {
2993 var $tip = $$$1(this.getTipElement());
2994 var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
2996 if (tabClass !== null && tabClass.length > 0) {
2997 $tip.removeClass(tabClass.join(''));
3001 _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(data) {
3002 this._cleanTipClass();
3004 this.addAttachmentClass(this._getAttachment(data.placement));
3007 _proto._fixTransition = function _fixTransition() {
3008 var tip = this.getTipElement();
3009 var initConfigAnimation = this.config.animation;
3011 if (tip.getAttribute('x-placement') !== null) {
3015 $$$1(tip).removeClass(ClassName.FADE);
3016 this.config.animation = false;
3019 this.config.animation = initConfigAnimation;
3023 Tooltip._jQueryInterface = function _jQueryInterface(config) {
3024 return this.each(function () {
3025 var data = $$$1(this).data(DATA_KEY);
3027 var _config = typeof config === 'object' && config;
3029 if (!data && /dispose|hide/.test(config)) {
3034 data = new Tooltip(this, _config);
3035 $$$1(this).data(DATA_KEY, data);
3038 if (typeof config === 'string') {
3039 if (typeof data[config] === 'undefined') {
3040 throw new TypeError("No method named \"" + config + "\"");
3048 _createClass(Tooltip, null, [{
3050 get: function get() {
3055 get: function get() {
3060 get: function get() {
3065 get: function get() {
3070 get: function get() {
3075 get: function get() {
3080 get: function get() {
3087 * ------------------------------------------------------------------------
3089 * ------------------------------------------------------------------------
3093 $$$1.fn[NAME] = Tooltip._jQueryInterface;
3094 $$$1.fn[NAME].Constructor = Tooltip;
3096 $$$1.fn[NAME].noConflict = function () {
3097 $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
3098 return Tooltip._jQueryInterface;
3105 * --------------------------------------------------------------------------
3106 * Bootstrap (v4.0.0): popover.js
3107 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
3108 * --------------------------------------------------------------------------
3111 var Popover = function ($$$1) {
3113 * ------------------------------------------------------------------------
3115 * ------------------------------------------------------------------------
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, {
3128 template: '<div class="popover" role="tooltip">' + '<div class="arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div></div>'
3130 var DefaultType = _extends({}, Tooltip.DefaultType, {
3131 content: '(string|element|function)'
3138 TITLE: '.popover-header',
3139 CONTENT: '.popover-body'
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
3153 * ------------------------------------------------------------------------
3155 * ------------------------------------------------------------------------
3162 function (_Tooltip) {
3163 _inheritsLoose(Popover, _Tooltip);
3165 function Popover() {
3166 return _Tooltip.apply(this, arguments) || this;
3169 var _proto = Popover.prototype;
3172 _proto.isWithContent = function isWithContent() {
3173 return this.getTitle() || this._getContent();
3176 _proto.addAttachmentClass = function addAttachmentClass(attachment) {
3177 $$$1(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
3180 _proto.getTipElement = function getTipElement() {
3181 this.tip = this.tip || $$$1(this.config.template)[0];
3185 _proto.setContent = function setContent() {
3186 var $tip = $$$1(this.getTipElement()); // We use append for html objects to maintain js events
3188 this.setElementContent($tip.find(Selector.TITLE), this.getTitle());
3190 var content = this._getContent();
3192 if (typeof content === 'function') {
3193 content = content.call(this.element);
3196 this.setElementContent($tip.find(Selector.CONTENT), content);
3197 $tip.removeClass(ClassName.FADE + " " + ClassName.SHOW);
3201 _proto._getContent = function _getContent() {
3202 return this.element.getAttribute('data-content') || this.config.content;
3205 _proto._cleanTipClass = function _cleanTipClass() {
3206 var $tip = $$$1(this.getTipElement());
3207 var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
3209 if (tabClass !== null && tabClass.length > 0) {
3210 $tip.removeClass(tabClass.join(''));
3215 Popover._jQueryInterface = function _jQueryInterface(config) {
3216 return this.each(function () {
3217 var data = $$$1(this).data(DATA_KEY);
3219 var _config = typeof config === 'object' ? config : null;
3221 if (!data && /destroy|hide/.test(config)) {
3226 data = new Popover(this, _config);
3227 $$$1(this).data(DATA_KEY, data);
3230 if (typeof config === 'string') {
3231 if (typeof data[config] === 'undefined') {
3232 throw new TypeError("No method named \"" + config + "\"");
3240 _createClass(Popover, null, [{
3243 get: function get() {
3248 get: function get() {
3253 get: function get() {
3258 get: function get() {
3263 get: function get() {
3268 get: function get() {
3273 get: function get() {
3280 * ------------------------------------------------------------------------
3282 * ------------------------------------------------------------------------
3286 $$$1.fn[NAME] = Popover._jQueryInterface;
3287 $$$1.fn[NAME].Constructor = Popover;
3289 $$$1.fn[NAME].noConflict = function () {
3290 $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
3291 return Popover._jQueryInterface;
3298 * --------------------------------------------------------------------------
3299 * Bootstrap (v4.0.0): scrollspy.js
3300 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
3301 * --------------------------------------------------------------------------
3304 var ScrollSpy = function ($$$1) {
3306 * ------------------------------------------------------------------------
3308 * ------------------------------------------------------------------------
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];
3324 target: '(string|element)'
3327 ACTIVATE: "activate" + EVENT_KEY,
3328 SCROLL: "scroll" + EVENT_KEY,
3329 LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY
3332 DROPDOWN_ITEM: 'dropdown-item',
3333 DROPDOWN_MENU: 'dropdown-menu',
3337 DATA_SPY: '[data-spy="scroll"]',
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'
3347 var OffsetMethod = {
3349 POSITION: 'position'
3351 * ------------------------------------------------------------------------
3353 * ------------------------------------------------------------------------
3361 function ScrollSpy(element, config) {
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);
3370 this._activeTarget = null;
3371 this._scrollHeight = 0;
3372 $$$1(this._scrollElement).on(Event.SCROLL, function (event) {
3373 return _this._process(event);
3381 var _proto = ScrollSpy.prototype;
3384 _proto.refresh = function refresh() {
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;
3392 this._scrollHeight = this._getScrollHeight();
3393 var targets = $$$1.makeArray($$$1(this._selector));
3394 targets.map(function (element) {
3396 var targetSelector = Util.getSelectorFromElement(element);
3398 if (targetSelector) {
3399 target = $$$1(targetSelector)[0];
3403 var targetBCR = target.getBoundingClientRect();
3405 if (targetBCR.width || targetBCR.height) {
3406 // TODO (fat): remove sketch reliance on jQuery position/offset
3407 return [$$$1(target)[offsetMethod]().top + offsetBase, targetSelector];
3412 }).filter(function (item) {
3414 }).sort(function (a, b) {
3416 }).forEach(function (item) {
3417 _this2._offsets.push(item[0]);
3419 _this2._targets.push(item[1]);
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;
3437 _proto._getConfig = function _getConfig(config) {
3438 config = _extends({}, Default, config);
3440 if (typeof config.target !== 'string') {
3441 var id = $$$1(config.target).attr('id');
3444 id = Util.getUID(NAME);
3445 $$$1(config.target).attr('id', id);
3448 config.target = "#" + id;
3451 Util.typeCheckConfig(NAME, config, DefaultType);
3455 _proto._getScrollTop = function _getScrollTop() {
3456 return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
3459 _proto._getScrollHeight = function _getScrollHeight() {
3460 return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
3463 _proto._getOffsetHeight = function _getOffsetHeight() {
3464 return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
3467 _proto._process = function _process() {
3468 var scrollTop = this._getScrollTop() + this._config.offset;
3470 var scrollHeight = this._getScrollHeight();
3472 var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
3474 if (this._scrollHeight !== scrollHeight) {
3478 if (scrollTop >= maxScroll) {
3479 var target = this._targets[this._targets.length - 1];
3481 if (this._activeTarget !== target) {
3482 this._activate(target);
3488 if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
3489 this._activeTarget = null;
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]);
3499 if (isActiveTarget) {
3500 this._activate(this._targets[i]);
3505 _proto._activate = function _activate(target) {
3506 this._activeTarget = target;
3510 var queries = this._selector.split(','); // eslint-disable-next-line arrow-body-style
3513 queries = queries.map(function (selector) {
3514 return selector + "[data-target=\"" + target + "\"]," + (selector + "[href=\"" + target + "\"]");
3516 var $link = $$$1(queries.join(','));
3518 if ($link.hasClass(ClassName.DROPDOWN_ITEM)) {
3519 $link.closest(Selector.DROPDOWN).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE);
3520 $link.addClass(ClassName.ACTIVE);
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
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
3528 $link.parents(Selector.NAV_LIST_GROUP).prev(Selector.NAV_ITEMS).children(Selector.NAV_LINKS).addClass(ClassName.ACTIVE);
3531 $$$1(this._scrollElement).trigger(Event.ACTIVATE, {
3532 relatedTarget: target
3536 _proto._clear = function _clear() {
3537 $$$1(this._selector).filter(Selector.ACTIVE).removeClass(ClassName.ACTIVE);
3541 ScrollSpy._jQueryInterface = function _jQueryInterface(config) {
3542 return this.each(function () {
3543 var data = $$$1(this).data(DATA_KEY);
3545 var _config = typeof config === 'object' && config;
3548 data = new ScrollSpy(this, _config);
3549 $$$1(this).data(DATA_KEY, data);
3552 if (typeof config === 'string') {
3553 if (typeof data[config] === 'undefined') {
3554 throw new TypeError("No method named \"" + config + "\"");
3562 _createClass(ScrollSpy, null, [{
3564 get: function get() {
3569 get: function get() {
3576 * ------------------------------------------------------------------------
3577 * Data Api implementation
3578 * ------------------------------------------------------------------------
3582 $$$1(window).on(Event.LOAD_DATA_API, function () {
3583 var scrollSpys = $$$1.makeArray($$$1(Selector.DATA_SPY));
3585 for (var i = scrollSpys.length; i--;) {
3586 var $spy = $$$1(scrollSpys[i]);
3588 ScrollSpy._jQueryInterface.call($spy, $spy.data());
3592 * ------------------------------------------------------------------------
3594 * ------------------------------------------------------------------------
3597 $$$1.fn[NAME] = ScrollSpy._jQueryInterface;
3598 $$$1.fn[NAME].Constructor = ScrollSpy;
3600 $$$1.fn[NAME].noConflict = function () {
3601 $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
3602 return ScrollSpy._jQueryInterface;
3609 * --------------------------------------------------------------------------
3610 * Bootstrap (v4.0.0): tab.js
3611 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
3612 * --------------------------------------------------------------------------
3615 var Tab = function ($$$1) {
3617 * ------------------------------------------------------------------------
3619 * ------------------------------------------------------------------------
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;
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
3636 DROPDOWN_MENU: 'dropdown-menu',
3638 DISABLED: 'disabled',
3643 DROPDOWN: '.dropdown',
3644 NAV_LIST_GROUP: '.nav, .list-group',
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'
3651 * ------------------------------------------------------------------------
3653 * ------------------------------------------------------------------------
3661 function Tab(element) {
3662 this._element = element;
3666 var _proto = Tab.prototype;
3669 _proto.show = function show() {
3672 if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $$$1(this._element).hasClass(ClassName.ACTIVE) || $$$1(this._element).hasClass(ClassName.DISABLED)) {
3678 var listElement = $$$1(this._element).closest(Selector.NAV_LIST_GROUP)[0];
3679 var selector = Util.getSelectorFromElement(this._element);
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];
3687 var hideEvent = $$$1.Event(Event.HIDE, {
3688 relatedTarget: this._element
3690 var showEvent = $$$1.Event(Event.SHOW, {
3691 relatedTarget: previous
3695 $$$1(previous).trigger(hideEvent);
3698 $$$1(this._element).trigger(showEvent);
3700 if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) {
3705 target = $$$1(selector)[0];
3708 this._activate(this._element, listElement);
3710 var complete = function complete() {
3711 var hiddenEvent = $$$1.Event(Event.HIDDEN, {
3712 relatedTarget: _this._element
3714 var shownEvent = $$$1.Event(Event.SHOWN, {
3715 relatedTarget: previous
3717 $$$1(previous).trigger(hiddenEvent);
3718 $$$1(_this._element).trigger(shownEvent);
3722 this._activate(target, target.parentNode, complete);
3728 _proto.dispose = function dispose() {
3729 $$$1.removeData(this._element, DATA_KEY);
3730 this._element = null;
3734 _proto._activate = function _activate(element, container, callback) {
3739 if (container.nodeName === 'UL') {
3740 activeElements = $$$1(container).find(Selector.ACTIVE_UL);
3742 activeElements = $$$1(container).children(Selector.ACTIVE);
3745 var active = activeElements[0];
3746 var isTransitioning = callback && Util.supportsTransitionEnd() && active && $$$1(active).hasClass(ClassName.FADE);
3748 var complete = function complete() {
3749 return _this2._transitionComplete(element, active, callback);
3752 if (active && isTransitioning) {
3753 $$$1(active).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
3759 _proto._transitionComplete = function _transitionComplete(element, active, callback) {
3761 $$$1(active).removeClass(ClassName.SHOW + " " + ClassName.ACTIVE);
3762 var dropdownChild = $$$1(active.parentNode).find(Selector.DROPDOWN_ACTIVE_CHILD)[0];
3764 if (dropdownChild) {
3765 $$$1(dropdownChild).removeClass(ClassName.ACTIVE);
3768 if (active.getAttribute('role') === 'tab') {
3769 active.setAttribute('aria-selected', false);
3773 $$$1(element).addClass(ClassName.ACTIVE);
3775 if (element.getAttribute('role') === 'tab') {
3776 element.setAttribute('aria-selected', true);
3779 Util.reflow(element);
3780 $$$1(element).addClass(ClassName.SHOW);
3782 if (element.parentNode && $$$1(element.parentNode).hasClass(ClassName.DROPDOWN_MENU)) {
3783 var dropdownElement = $$$1(element).closest(Selector.DROPDOWN)[0];
3785 if (dropdownElement) {
3786 $$$1(dropdownElement).find(Selector.DROPDOWN_TOGGLE).addClass(ClassName.ACTIVE);
3789 element.setAttribute('aria-expanded', true);
3798 Tab._jQueryInterface = function _jQueryInterface(config) {
3799 return this.each(function () {
3800 var $this = $$$1(this);
3801 var data = $this.data(DATA_KEY);
3804 data = new Tab(this);
3805 $this.data(DATA_KEY, data);
3808 if (typeof config === 'string') {
3809 if (typeof data[config] === 'undefined') {
3810 throw new TypeError("No method named \"" + config + "\"");
3818 _createClass(Tab, null, [{
3820 get: function get() {
3827 * ------------------------------------------------------------------------
3828 * Data Api implementation
3829 * ------------------------------------------------------------------------
3833 $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE, function (event) {
3834 event.preventDefault();
3836 Tab._jQueryInterface.call($$$1(this), 'show');
3839 * ------------------------------------------------------------------------
3841 * ------------------------------------------------------------------------
3844 $$$1.fn[NAME] = Tab._jQueryInterface;
3845 $$$1.fn[NAME].Constructor = Tab;
3847 $$$1.fn[NAME].noConflict = function () {
3848 $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
3849 return Tab._jQueryInterface;
3856 * --------------------------------------------------------------------------
3857 * Bootstrap (v4.0.0-alpha.6): index.js
3858 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
3859 * --------------------------------------------------------------------------
3863 if (typeof $$$1 === 'undefined') {
3864 throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.');
3867 var version = $$$1.fn.jquery.split(' ')[0].split('.');
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');
3879 exports.Util = Util;
3880 exports.Alert = Alert;
3881 exports.Button = Button;
3882 exports.Carousel = Carousel;
3883 exports.Collapse = Collapse;
3884 exports.Dropdown = Dropdown;
3885 exports.Modal = Modal;
3886 exports.Popover = Popover;
3887 exports.Scrollspy = ScrollSpy;
3889 exports.Tooltip = Tooltip;
3891 Object.defineProperty(exports, '__esModule', { value: true });
3894 //# sourceMappingURL=bootstrap.js.map