source: db_tsh/wwwroot/lib/bootstrap/dist/js/bootstrap.js

main
Last change on this file was 705d6f5, checked in by ardit <ardit@…>, 2 days ago

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