source: ProjectBuilder/devel/pb-server/js/bootstrap.js@ 2639

Last change on this file since 2639 was 2639, checked in by Bruno Cornec, 4 years ago

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