source: ProjectBuilder/devel/pb-server/js/bootstrap.bundle.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: 222.6 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')) :
8 typeof define === 'function' && define.amd ? define(['exports', 'jquery'], factory) :
9 (global = global || self, factory(global.bootstrap = {}, global.jQuery));
10}(this, (function (exports, $) { 'use strict';
11
12 $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
13
14 function _defineProperties(target, props) {
15 for (var i = 0; i < props.length; i++) {
16 var descriptor = props[i];
17 descriptor.enumerable = descriptor.enumerable || false;
18 descriptor.configurable = true;
19 if ("value" in descriptor) descriptor.writable = true;
20 Object.defineProperty(target, descriptor.key, descriptor);
21 }
22 }
23
24 function _createClass(Constructor, protoProps, staticProps) {
25 if (protoProps) _defineProperties(Constructor.prototype, protoProps);
26 if (staticProps) _defineProperties(Constructor, staticProps);
27 return Constructor;
28 }
29
30 function _defineProperty(obj, key, value) {
31 if (key in obj) {
32 Object.defineProperty(obj, key, {
33 value: value,
34 enumerable: true,
35 configurable: true,
36 writable: true
37 });
38 } else {
39 obj[key] = value;
40 }
41
42 return obj;
43 }
44
45 function ownKeys(object, enumerableOnly) {
46 var keys = Object.keys(object);
47
48 if (Object.getOwnPropertySymbols) {
49 var symbols = Object.getOwnPropertySymbols(object);
50 if (enumerableOnly) symbols = symbols.filter(function (sym) {
51 return Object.getOwnPropertyDescriptor(object, sym).enumerable;
52 });
53 keys.push.apply(keys, symbols);
54 }
55
56 return keys;
57 }
58
59 function _objectSpread2(target) {
60 for (var i = 1; i < arguments.length; i++) {
61 var source = arguments[i] != null ? arguments[i] : {};
62
63 if (i % 2) {
64 ownKeys(Object(source), true).forEach(function (key) {
65 _defineProperty(target, key, source[key]);
66 });
67 } else if (Object.getOwnPropertyDescriptors) {
68 Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
69 } else {
70 ownKeys(Object(source)).forEach(function (key) {
71 Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
72 });
73 }
74 }
75
76 return target;
77 }
78
79 function _inheritsLoose(subClass, superClass) {
80 subClass.prototype = Object.create(superClass.prototype);
81 subClass.prototype.constructor = subClass;
82 subClass.__proto__ = superClass;
83 }
84
85 /**
86 * --------------------------------------------------------------------------
87 * Bootstrap (v4.4.1): util.js
88 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
89 * --------------------------------------------------------------------------
90 */
91 /**
92 * ------------------------------------------------------------------------
93 * Private TransitionEnd Helpers
94 * ------------------------------------------------------------------------
95 */
96
97 var TRANSITION_END = 'transitionend';
98 var MAX_UID = 1000000;
99 var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
100
101 function toType(obj) {
102 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
103 }
104
105 function getSpecialTransitionEndEvent() {
106 return {
107 bindType: TRANSITION_END,
108 delegateType: TRANSITION_END,
109 handle: function handle(event) {
110 if ($(event.target).is(this)) {
111 return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params
112 }
113
114 return undefined; // eslint-disable-line no-undefined
115 }
116 };
117 }
118
119 function transitionEndEmulator(duration) {
120 var _this = this;
121
122 var called = false;
123 $(this).one(Util.TRANSITION_END, function () {
124 called = true;
125 });
126 setTimeout(function () {
127 if (!called) {
128 Util.triggerTransitionEnd(_this);
129 }
130 }, duration);
131 return this;
132 }
133
134 function setTransitionEndSupport() {
135 $.fn.emulateTransitionEnd = transitionEndEmulator;
136 $.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
137 }
138 /**
139 * --------------------------------------------------------------------------
140 * Public Util Api
141 * --------------------------------------------------------------------------
142 */
143
144
145 var Util = {
146 TRANSITION_END: 'bsTransitionEnd',
147 getUID: function getUID(prefix) {
148 do {
149 // eslint-disable-next-line no-bitwise
150 prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here
151 } while (document.getElementById(prefix));
152
153 return prefix;
154 },
155 getSelectorFromElement: function getSelectorFromElement(element) {
156 var selector = element.getAttribute('data-target');
157
158 if (!selector || selector === '#') {
159 var hrefAttr = element.getAttribute('href');
160 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : '';
161 }
162
163 try {
164 return document.querySelector(selector) ? selector : null;
165 } catch (err) {
166 return null;
167 }
168 },
169 getTransitionDurationFromElement: function getTransitionDurationFromElement(element) {
170 if (!element) {
171 return 0;
172 } // Get transition-duration of the element
173
174
175 var transitionDuration = $(element).css('transition-duration');
176 var transitionDelay = $(element).css('transition-delay');
177 var floatTransitionDuration = parseFloat(transitionDuration);
178 var floatTransitionDelay = parseFloat(transitionDelay); // Return 0 if element or transition duration is not found
179
180 if (!floatTransitionDuration && !floatTransitionDelay) {
181 return 0;
182 } // If multiple durations are defined, take the first
183
184
185 transitionDuration = transitionDuration.split(',')[0];
186 transitionDelay = transitionDelay.split(',')[0];
187 return (parseFloat(transitionDuration) + parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
188 },
189 reflow: function reflow(element) {
190 return element.offsetHeight;
191 },
192 triggerTransitionEnd: function triggerTransitionEnd(element) {
193 $(element).trigger(TRANSITION_END);
194 },
195 // TODO: Remove in v5
196 supportsTransitionEnd: function supportsTransitionEnd() {
197 return Boolean(TRANSITION_END);
198 },
199 isElement: function isElement(obj) {
200 return (obj[0] || obj).nodeType;
201 },
202 typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) {
203 for (var property in configTypes) {
204 if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
205 var expectedTypes = configTypes[property];
206 var value = config[property];
207 var valueType = value && Util.isElement(value) ? 'element' : toType(value);
208
209 if (!new RegExp(expectedTypes).test(valueType)) {
210 throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
211 }
212 }
213 }
214 },
215 findShadowRoot: function findShadowRoot(element) {
216 if (!document.documentElement.attachShadow) {
217 return null;
218 } // Can find the shadow root otherwise it'll return the document
219
220
221 if (typeof element.getRootNode === 'function') {
222 var root = element.getRootNode();
223 return root instanceof ShadowRoot ? root : null;
224 }
225
226 if (element instanceof ShadowRoot) {
227 return element;
228 } // when we don't find a shadow root
229
230
231 if (!element.parentNode) {
232 return null;
233 }
234
235 return Util.findShadowRoot(element.parentNode);
236 },
237 jQueryDetection: function jQueryDetection() {
238 if (typeof $ === 'undefined') {
239 throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.');
240 }
241
242 var version = $.fn.jquery.split(' ')[0].split('.');
243 var minMajor = 1;
244 var ltMajor = 2;
245 var minMinor = 9;
246 var minPatch = 1;
247 var maxMajor = 4;
248
249 if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) {
250 throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0');
251 }
252 }
253 };
254 Util.jQueryDetection();
255 setTransitionEndSupport();
256
257 /**
258 * ------------------------------------------------------------------------
259 * Constants
260 * ------------------------------------------------------------------------
261 */
262
263 var NAME = 'alert';
264 var VERSION = '4.4.1';
265 var DATA_KEY = 'bs.alert';
266 var EVENT_KEY = "." + DATA_KEY;
267 var DATA_API_KEY = '.data-api';
268 var JQUERY_NO_CONFLICT = $.fn[NAME];
269 var Selector = {
270 DISMISS: '[data-dismiss="alert"]'
271 };
272 var Event = {
273 CLOSE: "close" + EVENT_KEY,
274 CLOSED: "closed" + EVENT_KEY,
275 CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
276 };
277 var ClassName = {
278 ALERT: 'alert',
279 FADE: 'fade',
280 SHOW: 'show'
281 };
282 /**
283 * ------------------------------------------------------------------------
284 * Class Definition
285 * ------------------------------------------------------------------------
286 */
287
288 var Alert =
289 /*#__PURE__*/
290 function () {
291 function Alert(element) {
292 this._element = element;
293 } // Getters
294
295
296 var _proto = Alert.prototype;
297
298 // Public
299 _proto.close = function close(element) {
300 var rootElement = this._element;
301
302 if (element) {
303 rootElement = this._getRootElement(element);
304 }
305
306 var customEvent = this._triggerCloseEvent(rootElement);
307
308 if (customEvent.isDefaultPrevented()) {
309 return;
310 }
311
312 this._removeElement(rootElement);
313 };
314
315 _proto.dispose = function dispose() {
316 $.removeData(this._element, DATA_KEY);
317 this._element = null;
318 } // Private
319 ;
320
321 _proto._getRootElement = function _getRootElement(element) {
322 var selector = Util.getSelectorFromElement(element);
323 var parent = false;
324
325 if (selector) {
326 parent = document.querySelector(selector);
327 }
328
329 if (!parent) {
330 parent = $(element).closest("." + ClassName.ALERT)[0];
331 }
332
333 return parent;
334 };
335
336 _proto._triggerCloseEvent = function _triggerCloseEvent(element) {
337 var closeEvent = $.Event(Event.CLOSE);
338 $(element).trigger(closeEvent);
339 return closeEvent;
340 };
341
342 _proto._removeElement = function _removeElement(element) {
343 var _this = this;
344
345 $(element).removeClass(ClassName.SHOW);
346
347 if (!$(element).hasClass(ClassName.FADE)) {
348 this._destroyElement(element);
349
350 return;
351 }
352
353 var transitionDuration = Util.getTransitionDurationFromElement(element);
354 $(element).one(Util.TRANSITION_END, function (event) {
355 return _this._destroyElement(element, event);
356 }).emulateTransitionEnd(transitionDuration);
357 };
358
359 _proto._destroyElement = function _destroyElement(element) {
360 $(element).detach().trigger(Event.CLOSED).remove();
361 } // Static
362 ;
363
364 Alert._jQueryInterface = function _jQueryInterface(config) {
365 return this.each(function () {
366 var $element = $(this);
367 var data = $element.data(DATA_KEY);
368
369 if (!data) {
370 data = new Alert(this);
371 $element.data(DATA_KEY, data);
372 }
373
374 if (config === 'close') {
375 data[config](this);
376 }
377 });
378 };
379
380 Alert._handleDismiss = function _handleDismiss(alertInstance) {
381 return function (event) {
382 if (event) {
383 event.preventDefault();
384 }
385
386 alertInstance.close(this);
387 };
388 };
389
390 _createClass(Alert, null, [{
391 key: "VERSION",
392 get: function get() {
393 return VERSION;
394 }
395 }]);
396
397 return Alert;
398 }();
399 /**
400 * ------------------------------------------------------------------------
401 * Data Api implementation
402 * ------------------------------------------------------------------------
403 */
404
405
406 $(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert()));
407 /**
408 * ------------------------------------------------------------------------
409 * jQuery
410 * ------------------------------------------------------------------------
411 */
412
413 $.fn[NAME] = Alert._jQueryInterface;
414 $.fn[NAME].Constructor = Alert;
415
416 $.fn[NAME].noConflict = function () {
417 $.fn[NAME] = JQUERY_NO_CONFLICT;
418 return Alert._jQueryInterface;
419 };
420
421 /**
422 * ------------------------------------------------------------------------
423 * Constants
424 * ------------------------------------------------------------------------
425 */
426
427 var NAME$1 = 'button';
428 var VERSION$1 = '4.4.1';
429 var DATA_KEY$1 = 'bs.button';
430 var EVENT_KEY$1 = "." + DATA_KEY$1;
431 var DATA_API_KEY$1 = '.data-api';
432 var JQUERY_NO_CONFLICT$1 = $.fn[NAME$1];
433 var ClassName$1 = {
434 ACTIVE: 'active',
435 BUTTON: 'btn',
436 FOCUS: 'focus'
437 };
438 var Selector$1 = {
439 DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
440 DATA_TOGGLES: '[data-toggle="buttons"]',
441 DATA_TOGGLE: '[data-toggle="button"]',
442 DATA_TOGGLES_BUTTONS: '[data-toggle="buttons"] .btn',
443 INPUT: 'input:not([type="hidden"])',
444 ACTIVE: '.active',
445 BUTTON: '.btn'
446 };
447 var Event$1 = {
448 CLICK_DATA_API: "click" + EVENT_KEY$1 + DATA_API_KEY$1,
449 FOCUS_BLUR_DATA_API: "focus" + EVENT_KEY$1 + DATA_API_KEY$1 + " " + ("blur" + EVENT_KEY$1 + DATA_API_KEY$1),
450 LOAD_DATA_API: "load" + EVENT_KEY$1 + DATA_API_KEY$1
451 };
452 /**
453 * ------------------------------------------------------------------------
454 * Class Definition
455 * ------------------------------------------------------------------------
456 */
457
458 var Button =
459 /*#__PURE__*/
460 function () {
461 function Button(element) {
462 this._element = element;
463 } // Getters
464
465
466 var _proto = Button.prototype;
467
468 // Public
469 _proto.toggle = function toggle() {
470 var triggerChangeEvent = true;
471 var addAriaPressed = true;
472 var rootElement = $(this._element).closest(Selector$1.DATA_TOGGLES)[0];
473
474 if (rootElement) {
475 var input = this._element.querySelector(Selector$1.INPUT);
476
477 if (input) {
478 if (input.type === 'radio') {
479 if (input.checked && this._element.classList.contains(ClassName$1.ACTIVE)) {
480 triggerChangeEvent = false;
481 } else {
482 var activeElement = rootElement.querySelector(Selector$1.ACTIVE);
483
484 if (activeElement) {
485 $(activeElement).removeClass(ClassName$1.ACTIVE);
486 }
487 }
488 } else if (input.type === 'checkbox') {
489 if (this._element.tagName === 'LABEL' && input.checked === this._element.classList.contains(ClassName$1.ACTIVE)) {
490 triggerChangeEvent = false;
491 }
492 } else {
493 // if it's not a radio button or checkbox don't add a pointless/invalid checked property to the input
494 triggerChangeEvent = false;
495 }
496
497 if (triggerChangeEvent) {
498 input.checked = !this._element.classList.contains(ClassName$1.ACTIVE);
499 $(input).trigger('change');
500 }
501
502 input.focus();
503 addAriaPressed = false;
504 }
505 }
506
507 if (!(this._element.hasAttribute('disabled') || this._element.classList.contains('disabled'))) {
508 if (addAriaPressed) {
509 this._element.setAttribute('aria-pressed', !this._element.classList.contains(ClassName$1.ACTIVE));
510 }
511
512 if (triggerChangeEvent) {
513 $(this._element).toggleClass(ClassName$1.ACTIVE);
514 }
515 }
516 };
517
518 _proto.dispose = function dispose() {
519 $.removeData(this._element, DATA_KEY$1);
520 this._element = null;
521 } // Static
522 ;
523
524 Button._jQueryInterface = function _jQueryInterface(config) {
525 return this.each(function () {
526 var data = $(this).data(DATA_KEY$1);
527
528 if (!data) {
529 data = new Button(this);
530 $(this).data(DATA_KEY$1, data);
531 }
532
533 if (config === 'toggle') {
534 data[config]();
535 }
536 });
537 };
538
539 _createClass(Button, null, [{
540 key: "VERSION",
541 get: function get() {
542 return VERSION$1;
543 }
544 }]);
545
546 return Button;
547 }();
548 /**
549 * ------------------------------------------------------------------------
550 * Data Api implementation
551 * ------------------------------------------------------------------------
552 */
553
554
555 $(document).on(Event$1.CLICK_DATA_API, Selector$1.DATA_TOGGLE_CARROT, function (event) {
556 var button = event.target;
557
558 if (!$(button).hasClass(ClassName$1.BUTTON)) {
559 button = $(button).closest(Selector$1.BUTTON)[0];
560 }
561
562 if (!button || button.hasAttribute('disabled') || button.classList.contains('disabled')) {
563 event.preventDefault(); // work around Firefox bug #1540995
564 } else {
565 var inputBtn = button.querySelector(Selector$1.INPUT);
566
567 if (inputBtn && (inputBtn.hasAttribute('disabled') || inputBtn.classList.contains('disabled'))) {
568 event.preventDefault(); // work around Firefox bug #1540995
569
570 return;
571 }
572
573 Button._jQueryInterface.call($(button), 'toggle');
574 }
575 }).on(Event$1.FOCUS_BLUR_DATA_API, Selector$1.DATA_TOGGLE_CARROT, function (event) {
576 var button = $(event.target).closest(Selector$1.BUTTON)[0];
577 $(button).toggleClass(ClassName$1.FOCUS, /^focus(in)?$/.test(event.type));
578 });
579 $(window).on(Event$1.LOAD_DATA_API, function () {
580 // ensure correct active class is set to match the controls' actual values/states
581 // find all checkboxes/readio buttons inside data-toggle groups
582 var buttons = [].slice.call(document.querySelectorAll(Selector$1.DATA_TOGGLES_BUTTONS));
583
584 for (var i = 0, len = buttons.length; i < len; i++) {
585 var button = buttons[i];
586 var input = button.querySelector(Selector$1.INPUT);
587
588 if (input.checked || input.hasAttribute('checked')) {
589 button.classList.add(ClassName$1.ACTIVE);
590 } else {
591 button.classList.remove(ClassName$1.ACTIVE);
592 }
593 } // find all button toggles
594
595
596 buttons = [].slice.call(document.querySelectorAll(Selector$1.DATA_TOGGLE));
597
598 for (var _i = 0, _len = buttons.length; _i < _len; _i++) {
599 var _button = buttons[_i];
600
601 if (_button.getAttribute('aria-pressed') === 'true') {
602 _button.classList.add(ClassName$1.ACTIVE);
603 } else {
604 _button.classList.remove(ClassName$1.ACTIVE);
605 }
606 }
607 });
608 /**
609 * ------------------------------------------------------------------------
610 * jQuery
611 * ------------------------------------------------------------------------
612 */
613
614 $.fn[NAME$1] = Button._jQueryInterface;
615 $.fn[NAME$1].Constructor = Button;
616
617 $.fn[NAME$1].noConflict = function () {
618 $.fn[NAME$1] = JQUERY_NO_CONFLICT$1;
619 return Button._jQueryInterface;
620 };
621
622 /**
623 * ------------------------------------------------------------------------
624 * Constants
625 * ------------------------------------------------------------------------
626 */
627
628 var NAME$2 = 'carousel';
629 var VERSION$2 = '4.4.1';
630 var DATA_KEY$2 = 'bs.carousel';
631 var EVENT_KEY$2 = "." + DATA_KEY$2;
632 var DATA_API_KEY$2 = '.data-api';
633 var JQUERY_NO_CONFLICT$2 = $.fn[NAME$2];
634 var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key
635
636 var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key
637
638 var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
639
640 var SWIPE_THRESHOLD = 40;
641 var Default = {
642 interval: 5000,
643 keyboard: true,
644 slide: false,
645 pause: 'hover',
646 wrap: true,
647 touch: true
648 };
649 var DefaultType = {
650 interval: '(number|boolean)',
651 keyboard: 'boolean',
652 slide: '(boolean|string)',
653 pause: '(string|boolean)',
654 wrap: 'boolean',
655 touch: 'boolean'
656 };
657 var Direction = {
658 NEXT: 'next',
659 PREV: 'prev',
660 LEFT: 'left',
661 RIGHT: 'right'
662 };
663 var Event$2 = {
664 SLIDE: "slide" + EVENT_KEY$2,
665 SLID: "slid" + EVENT_KEY$2,
666 KEYDOWN: "keydown" + EVENT_KEY$2,
667 MOUSEENTER: "mouseenter" + EVENT_KEY$2,
668 MOUSELEAVE: "mouseleave" + EVENT_KEY$2,
669 TOUCHSTART: "touchstart" + EVENT_KEY$2,
670 TOUCHMOVE: "touchmove" + EVENT_KEY$2,
671 TOUCHEND: "touchend" + EVENT_KEY$2,
672 POINTERDOWN: "pointerdown" + EVENT_KEY$2,
673 POINTERUP: "pointerup" + EVENT_KEY$2,
674 DRAG_START: "dragstart" + EVENT_KEY$2,
675 LOAD_DATA_API: "load" + EVENT_KEY$2 + DATA_API_KEY$2,
676 CLICK_DATA_API: "click" + EVENT_KEY$2 + DATA_API_KEY$2
677 };
678 var ClassName$2 = {
679 CAROUSEL: 'carousel',
680 ACTIVE: 'active',
681 SLIDE: 'slide',
682 RIGHT: 'carousel-item-right',
683 LEFT: 'carousel-item-left',
684 NEXT: 'carousel-item-next',
685 PREV: 'carousel-item-prev',
686 ITEM: 'carousel-item',
687 POINTER_EVENT: 'pointer-event'
688 };
689 var Selector$2 = {
690 ACTIVE: '.active',
691 ACTIVE_ITEM: '.active.carousel-item',
692 ITEM: '.carousel-item',
693 ITEM_IMG: '.carousel-item img',
694 NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
695 INDICATORS: '.carousel-indicators',
696 DATA_SLIDE: '[data-slide], [data-slide-to]',
697 DATA_RIDE: '[data-ride="carousel"]'
698 };
699 var PointerType = {
700 TOUCH: 'touch',
701 PEN: 'pen'
702 };
703 /**
704 * ------------------------------------------------------------------------
705 * Class Definition
706 * ------------------------------------------------------------------------
707 */
708
709 var Carousel =
710 /*#__PURE__*/
711 function () {
712 function Carousel(element, config) {
713 this._items = null;
714 this._interval = null;
715 this._activeElement = null;
716 this._isPaused = false;
717 this._isSliding = false;
718 this.touchTimeout = null;
719 this.touchStartX = 0;
720 this.touchDeltaX = 0;
721 this._config = this._getConfig(config);
722 this._element = element;
723 this._indicatorsElement = this._element.querySelector(Selector$2.INDICATORS);
724 this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
725 this._pointerEvent = Boolean(window.PointerEvent || window.MSPointerEvent);
726
727 this._addEventListeners();
728 } // Getters
729
730
731 var _proto = Carousel.prototype;
732
733 // Public
734 _proto.next = function next() {
735 if (!this._isSliding) {
736 this._slide(Direction.NEXT);
737 }
738 };
739
740 _proto.nextWhenVisible = function nextWhenVisible() {
741 // Don't call next when the page isn't visible
742 // or the carousel or its parent isn't visible
743 if (!document.hidden && $(this._element).is(':visible') && $(this._element).css('visibility') !== 'hidden') {
744 this.next();
745 }
746 };
747
748 _proto.prev = function prev() {
749 if (!this._isSliding) {
750 this._slide(Direction.PREV);
751 }
752 };
753
754 _proto.pause = function pause(event) {
755 if (!event) {
756 this._isPaused = true;
757 }
758
759 if (this._element.querySelector(Selector$2.NEXT_PREV)) {
760 Util.triggerTransitionEnd(this._element);
761 this.cycle(true);
762 }
763
764 clearInterval(this._interval);
765 this._interval = null;
766 };
767
768 _proto.cycle = function cycle(event) {
769 if (!event) {
770 this._isPaused = false;
771 }
772
773 if (this._interval) {
774 clearInterval(this._interval);
775 this._interval = null;
776 }
777
778 if (this._config.interval && !this._isPaused) {
779 this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
780 }
781 };
782
783 _proto.to = function to(index) {
784 var _this = this;
785
786 this._activeElement = this._element.querySelector(Selector$2.ACTIVE_ITEM);
787
788 var activeIndex = this._getItemIndex(this._activeElement);
789
790 if (index > this._items.length - 1 || index < 0) {
791 return;
792 }
793
794 if (this._isSliding) {
795 $(this._element).one(Event$2.SLID, function () {
796 return _this.to(index);
797 });
798 return;
799 }
800
801 if (activeIndex === index) {
802 this.pause();
803 this.cycle();
804 return;
805 }
806
807 var direction = index > activeIndex ? Direction.NEXT : Direction.PREV;
808
809 this._slide(direction, this._items[index]);
810 };
811
812 _proto.dispose = function dispose() {
813 $(this._element).off(EVENT_KEY$2);
814 $.removeData(this._element, DATA_KEY$2);
815 this._items = null;
816 this._config = null;
817 this._element = null;
818 this._interval = null;
819 this._isPaused = null;
820 this._isSliding = null;
821 this._activeElement = null;
822 this._indicatorsElement = null;
823 } // Private
824 ;
825
826 _proto._getConfig = function _getConfig(config) {
827 config = _objectSpread2({}, Default, {}, config);
828 Util.typeCheckConfig(NAME$2, config, DefaultType);
829 return config;
830 };
831
832 _proto._handleSwipe = function _handleSwipe() {
833 var absDeltax = Math.abs(this.touchDeltaX);
834
835 if (absDeltax <= SWIPE_THRESHOLD) {
836 return;
837 }
838
839 var direction = absDeltax / this.touchDeltaX;
840 this.touchDeltaX = 0; // swipe left
841
842 if (direction > 0) {
843 this.prev();
844 } // swipe right
845
846
847 if (direction < 0) {
848 this.next();
849 }
850 };
851
852 _proto._addEventListeners = function _addEventListeners() {
853 var _this2 = this;
854
855 if (this._config.keyboard) {
856 $(this._element).on(Event$2.KEYDOWN, function (event) {
857 return _this2._keydown(event);
858 });
859 }
860
861 if (this._config.pause === 'hover') {
862 $(this._element).on(Event$2.MOUSEENTER, function (event) {
863 return _this2.pause(event);
864 }).on(Event$2.MOUSELEAVE, function (event) {
865 return _this2.cycle(event);
866 });
867 }
868
869 if (this._config.touch) {
870 this._addTouchEventListeners();
871 }
872 };
873
874 _proto._addTouchEventListeners = function _addTouchEventListeners() {
875 var _this3 = this;
876
877 if (!this._touchSupported) {
878 return;
879 }
880
881 var start = function start(event) {
882 if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) {
883 _this3.touchStartX = event.originalEvent.clientX;
884 } else if (!_this3._pointerEvent) {
885 _this3.touchStartX = event.originalEvent.touches[0].clientX;
886 }
887 };
888
889 var move = function move(event) {
890 // ensure swiping with one touch and not pinching
891 if (event.originalEvent.touches && event.originalEvent.touches.length > 1) {
892 _this3.touchDeltaX = 0;
893 } else {
894 _this3.touchDeltaX = event.originalEvent.touches[0].clientX - _this3.touchStartX;
895 }
896 };
897
898 var end = function end(event) {
899 if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) {
900 _this3.touchDeltaX = event.originalEvent.clientX - _this3.touchStartX;
901 }
902
903 _this3._handleSwipe();
904
905 if (_this3._config.pause === 'hover') {
906 // If it's a touch-enabled device, mouseenter/leave are fired as
907 // part of the mouse compatibility events on first tap - the carousel
908 // would stop cycling until user tapped out of it;
909 // here, we listen for touchend, explicitly pause the carousel
910 // (as if it's the second time we tap on it, mouseenter compat event
911 // is NOT fired) and after a timeout (to allow for mouse compatibility
912 // events to fire) we explicitly restart cycling
913 _this3.pause();
914
915 if (_this3.touchTimeout) {
916 clearTimeout(_this3.touchTimeout);
917 }
918
919 _this3.touchTimeout = setTimeout(function (event) {
920 return _this3.cycle(event);
921 }, TOUCHEVENT_COMPAT_WAIT + _this3._config.interval);
922 }
923 };
924
925 $(this._element.querySelectorAll(Selector$2.ITEM_IMG)).on(Event$2.DRAG_START, function (e) {
926 return e.preventDefault();
927 });
928
929 if (this._pointerEvent) {
930 $(this._element).on(Event$2.POINTERDOWN, function (event) {
931 return start(event);
932 });
933 $(this._element).on(Event$2.POINTERUP, function (event) {
934 return end(event);
935 });
936
937 this._element.classList.add(ClassName$2.POINTER_EVENT);
938 } else {
939 $(this._element).on(Event$2.TOUCHSTART, function (event) {
940 return start(event);
941 });
942 $(this._element).on(Event$2.TOUCHMOVE, function (event) {
943 return move(event);
944 });
945 $(this._element).on(Event$2.TOUCHEND, function (event) {
946 return end(event);
947 });
948 }
949 };
950
951 _proto._keydown = function _keydown(event) {
952 if (/input|textarea/i.test(event.target.tagName)) {
953 return;
954 }
955
956 switch (event.which) {
957 case ARROW_LEFT_KEYCODE:
958 event.preventDefault();
959 this.prev();
960 break;
961
962 case ARROW_RIGHT_KEYCODE:
963 event.preventDefault();
964 this.next();
965 break;
966 }
967 };
968
969 _proto._getItemIndex = function _getItemIndex(element) {
970 this._items = element && element.parentNode ? [].slice.call(element.parentNode.querySelectorAll(Selector$2.ITEM)) : [];
971 return this._items.indexOf(element);
972 };
973
974 _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
975 var isNextDirection = direction === Direction.NEXT;
976 var isPrevDirection = direction === Direction.PREV;
977
978 var activeIndex = this._getItemIndex(activeElement);
979
980 var lastItemIndex = this._items.length - 1;
981 var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex;
982
983 if (isGoingToWrap && !this._config.wrap) {
984 return activeElement;
985 }
986
987 var delta = direction === Direction.PREV ? -1 : 1;
988 var itemIndex = (activeIndex + delta) % this._items.length;
989 return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
990 };
991
992 _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
993 var targetIndex = this._getItemIndex(relatedTarget);
994
995 var fromIndex = this._getItemIndex(this._element.querySelector(Selector$2.ACTIVE_ITEM));
996
997 var slideEvent = $.Event(Event$2.SLIDE, {
998 relatedTarget: relatedTarget,
999 direction: eventDirectionName,
1000 from: fromIndex,
1001 to: targetIndex
1002 });
1003 $(this._element).trigger(slideEvent);
1004 return slideEvent;
1005 };
1006
1007 _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
1008 if (this._indicatorsElement) {
1009 var indicators = [].slice.call(this._indicatorsElement.querySelectorAll(Selector$2.ACTIVE));
1010 $(indicators).removeClass(ClassName$2.ACTIVE);
1011
1012 var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)];
1013
1014 if (nextIndicator) {
1015 $(nextIndicator).addClass(ClassName$2.ACTIVE);
1016 }
1017 }
1018 };
1019
1020 _proto._slide = function _slide(direction, element) {
1021 var _this4 = this;
1022
1023 var activeElement = this._element.querySelector(Selector$2.ACTIVE_ITEM);
1024
1025 var activeElementIndex = this._getItemIndex(activeElement);
1026
1027 var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement);
1028
1029 var nextElementIndex = this._getItemIndex(nextElement);
1030
1031 var isCycling = Boolean(this._interval);
1032 var directionalClassName;
1033 var orderClassName;
1034 var eventDirectionName;
1035
1036 if (direction === Direction.NEXT) {
1037 directionalClassName = ClassName$2.LEFT;
1038 orderClassName = ClassName$2.NEXT;
1039 eventDirectionName = Direction.LEFT;
1040 } else {
1041 directionalClassName = ClassName$2.RIGHT;
1042 orderClassName = ClassName$2.PREV;
1043 eventDirectionName = Direction.RIGHT;
1044 }
1045
1046 if (nextElement && $(nextElement).hasClass(ClassName$2.ACTIVE)) {
1047 this._isSliding = false;
1048 return;
1049 }
1050
1051 var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
1052
1053 if (slideEvent.isDefaultPrevented()) {
1054 return;
1055 }
1056
1057 if (!activeElement || !nextElement) {
1058 // Some weirdness is happening, so we bail
1059 return;
1060 }
1061
1062 this._isSliding = true;
1063
1064 if (isCycling) {
1065 this.pause();
1066 }
1067
1068 this._setActiveIndicatorElement(nextElement);
1069
1070 var slidEvent = $.Event(Event$2.SLID, {
1071 relatedTarget: nextElement,
1072 direction: eventDirectionName,
1073 from: activeElementIndex,
1074 to: nextElementIndex
1075 });
1076
1077 if ($(this._element).hasClass(ClassName$2.SLIDE)) {
1078 $(nextElement).addClass(orderClassName);
1079 Util.reflow(nextElement);
1080 $(activeElement).addClass(directionalClassName);
1081 $(nextElement).addClass(directionalClassName);
1082 var nextElementInterval = parseInt(nextElement.getAttribute('data-interval'), 10);
1083
1084 if (nextElementInterval) {
1085 this._config.defaultInterval = this._config.defaultInterval || this._config.interval;
1086 this._config.interval = nextElementInterval;
1087 } else {
1088 this._config.interval = this._config.defaultInterval || this._config.interval;
1089 }
1090
1091 var transitionDuration = Util.getTransitionDurationFromElement(activeElement);
1092 $(activeElement).one(Util.TRANSITION_END, function () {
1093 $(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName$2.ACTIVE);
1094 $(activeElement).removeClass(ClassName$2.ACTIVE + " " + orderClassName + " " + directionalClassName);
1095 _this4._isSliding = false;
1096 setTimeout(function () {
1097 return $(_this4._element).trigger(slidEvent);
1098 }, 0);
1099 }).emulateTransitionEnd(transitionDuration);
1100 } else {
1101 $(activeElement).removeClass(ClassName$2.ACTIVE);
1102 $(nextElement).addClass(ClassName$2.ACTIVE);
1103 this._isSliding = false;
1104 $(this._element).trigger(slidEvent);
1105 }
1106
1107 if (isCycling) {
1108 this.cycle();
1109 }
1110 } // Static
1111 ;
1112
1113 Carousel._jQueryInterface = function _jQueryInterface(config) {
1114 return this.each(function () {
1115 var data = $(this).data(DATA_KEY$2);
1116
1117 var _config = _objectSpread2({}, Default, {}, $(this).data());
1118
1119 if (typeof config === 'object') {
1120 _config = _objectSpread2({}, _config, {}, config);
1121 }
1122
1123 var action = typeof config === 'string' ? config : _config.slide;
1124
1125 if (!data) {
1126 data = new Carousel(this, _config);
1127 $(this).data(DATA_KEY$2, data);
1128 }
1129
1130 if (typeof config === 'number') {
1131 data.to(config);
1132 } else if (typeof action === 'string') {
1133 if (typeof data[action] === 'undefined') {
1134 throw new TypeError("No method named \"" + action + "\"");
1135 }
1136
1137 data[action]();
1138 } else if (_config.interval && _config.ride) {
1139 data.pause();
1140 data.cycle();
1141 }
1142 });
1143 };
1144
1145 Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
1146 var selector = Util.getSelectorFromElement(this);
1147
1148 if (!selector) {
1149 return;
1150 }
1151
1152 var target = $(selector)[0];
1153
1154 if (!target || !$(target).hasClass(ClassName$2.CAROUSEL)) {
1155 return;
1156 }
1157
1158 var config = _objectSpread2({}, $(target).data(), {}, $(this).data());
1159
1160 var slideIndex = this.getAttribute('data-slide-to');
1161
1162 if (slideIndex) {
1163 config.interval = false;
1164 }
1165
1166 Carousel._jQueryInterface.call($(target), config);
1167
1168 if (slideIndex) {
1169 $(target).data(DATA_KEY$2).to(slideIndex);
1170 }
1171
1172 event.preventDefault();
1173 };
1174
1175 _createClass(Carousel, null, [{
1176 key: "VERSION",
1177 get: function get() {
1178 return VERSION$2;
1179 }
1180 }, {
1181 key: "Default",
1182 get: function get() {
1183 return Default;
1184 }
1185 }]);
1186
1187 return Carousel;
1188 }();
1189 /**
1190 * ------------------------------------------------------------------------
1191 * Data Api implementation
1192 * ------------------------------------------------------------------------
1193 */
1194
1195
1196 $(document).on(Event$2.CLICK_DATA_API, Selector$2.DATA_SLIDE, Carousel._dataApiClickHandler);
1197 $(window).on(Event$2.LOAD_DATA_API, function () {
1198 var carousels = [].slice.call(document.querySelectorAll(Selector$2.DATA_RIDE));
1199
1200 for (var i = 0, len = carousels.length; i < len; i++) {
1201 var $carousel = $(carousels[i]);
1202
1203 Carousel._jQueryInterface.call($carousel, $carousel.data());
1204 }
1205 });
1206 /**
1207 * ------------------------------------------------------------------------
1208 * jQuery
1209 * ------------------------------------------------------------------------
1210 */
1211
1212 $.fn[NAME$2] = Carousel._jQueryInterface;
1213 $.fn[NAME$2].Constructor = Carousel;
1214
1215 $.fn[NAME$2].noConflict = function () {
1216 $.fn[NAME$2] = JQUERY_NO_CONFLICT$2;
1217 return Carousel._jQueryInterface;
1218 };
1219
1220 /**
1221 * ------------------------------------------------------------------------
1222 * Constants
1223 * ------------------------------------------------------------------------
1224 */
1225
1226 var NAME$3 = 'collapse';
1227 var VERSION$3 = '4.4.1';
1228 var DATA_KEY$3 = 'bs.collapse';
1229 var EVENT_KEY$3 = "." + DATA_KEY$3;
1230 var DATA_API_KEY$3 = '.data-api';
1231 var JQUERY_NO_CONFLICT$3 = $.fn[NAME$3];
1232 var Default$1 = {
1233 toggle: true,
1234 parent: ''
1235 };
1236 var DefaultType$1 = {
1237 toggle: 'boolean',
1238 parent: '(string|element)'
1239 };
1240 var Event$3 = {
1241 SHOW: "show" + EVENT_KEY$3,
1242 SHOWN: "shown" + EVENT_KEY$3,
1243 HIDE: "hide" + EVENT_KEY$3,
1244 HIDDEN: "hidden" + EVENT_KEY$3,
1245 CLICK_DATA_API: "click" + EVENT_KEY$3 + DATA_API_KEY$3
1246 };
1247 var ClassName$3 = {
1248 SHOW: 'show',
1249 COLLAPSE: 'collapse',
1250 COLLAPSING: 'collapsing',
1251 COLLAPSED: 'collapsed'
1252 };
1253 var Dimension = {
1254 WIDTH: 'width',
1255 HEIGHT: 'height'
1256 };
1257 var Selector$3 = {
1258 ACTIVES: '.show, .collapsing',
1259 DATA_TOGGLE: '[data-toggle="collapse"]'
1260 };
1261 /**
1262 * ------------------------------------------------------------------------
1263 * Class Definition
1264 * ------------------------------------------------------------------------
1265 */
1266
1267 var Collapse =
1268 /*#__PURE__*/
1269 function () {
1270 function Collapse(element, config) {
1271 this._isTransitioning = false;
1272 this._element = element;
1273 this._config = this._getConfig(config);
1274 this._triggerArray = [].slice.call(document.querySelectorAll("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]")));
1275 var toggleList = [].slice.call(document.querySelectorAll(Selector$3.DATA_TOGGLE));
1276
1277 for (var i = 0, len = toggleList.length; i < len; i++) {
1278 var elem = toggleList[i];
1279 var selector = Util.getSelectorFromElement(elem);
1280 var filterElement = [].slice.call(document.querySelectorAll(selector)).filter(function (foundElem) {
1281 return foundElem === element;
1282 });
1283
1284 if (selector !== null && filterElement.length > 0) {
1285 this._selector = selector;
1286
1287 this._triggerArray.push(elem);
1288 }
1289 }
1290
1291 this._parent = this._config.parent ? this._getParent() : null;
1292
1293 if (!this._config.parent) {
1294 this._addAriaAndCollapsedClass(this._element, this._triggerArray);
1295 }
1296
1297 if (this._config.toggle) {
1298 this.toggle();
1299 }
1300 } // Getters
1301
1302
1303 var _proto = Collapse.prototype;
1304
1305 // Public
1306 _proto.toggle = function toggle() {
1307 if ($(this._element).hasClass(ClassName$3.SHOW)) {
1308 this.hide();
1309 } else {
1310 this.show();
1311 }
1312 };
1313
1314 _proto.show = function show() {
1315 var _this = this;
1316
1317 if (this._isTransitioning || $(this._element).hasClass(ClassName$3.SHOW)) {
1318 return;
1319 }
1320
1321 var actives;
1322 var activesData;
1323
1324 if (this._parent) {
1325 actives = [].slice.call(this._parent.querySelectorAll(Selector$3.ACTIVES)).filter(function (elem) {
1326 if (typeof _this._config.parent === 'string') {
1327 return elem.getAttribute('data-parent') === _this._config.parent;
1328 }
1329
1330 return elem.classList.contains(ClassName$3.COLLAPSE);
1331 });
1332
1333 if (actives.length === 0) {
1334 actives = null;
1335 }
1336 }
1337
1338 if (actives) {
1339 activesData = $(actives).not(this._selector).data(DATA_KEY$3);
1340
1341 if (activesData && activesData._isTransitioning) {
1342 return;
1343 }
1344 }
1345
1346 var startEvent = $.Event(Event$3.SHOW);
1347 $(this._element).trigger(startEvent);
1348
1349 if (startEvent.isDefaultPrevented()) {
1350 return;
1351 }
1352
1353 if (actives) {
1354 Collapse._jQueryInterface.call($(actives).not(this._selector), 'hide');
1355
1356 if (!activesData) {
1357 $(actives).data(DATA_KEY$3, null);
1358 }
1359 }
1360
1361 var dimension = this._getDimension();
1362
1363 $(this._element).removeClass(ClassName$3.COLLAPSE).addClass(ClassName$3.COLLAPSING);
1364 this._element.style[dimension] = 0;
1365
1366 if (this._triggerArray.length) {
1367 $(this._triggerArray).removeClass(ClassName$3.COLLAPSED).attr('aria-expanded', true);
1368 }
1369
1370 this.setTransitioning(true);
1371
1372 var complete = function complete() {
1373 $(_this._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).addClass(ClassName$3.SHOW);
1374 _this._element.style[dimension] = '';
1375
1376 _this.setTransitioning(false);
1377
1378 $(_this._element).trigger(Event$3.SHOWN);
1379 };
1380
1381 var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
1382 var scrollSize = "scroll" + capitalizedDimension;
1383 var transitionDuration = Util.getTransitionDurationFromElement(this._element);
1384 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
1385 this._element.style[dimension] = this._element[scrollSize] + "px";
1386 };
1387
1388 _proto.hide = function hide() {
1389 var _this2 = this;
1390
1391 if (this._isTransitioning || !$(this._element).hasClass(ClassName$3.SHOW)) {
1392 return;
1393 }
1394
1395 var startEvent = $.Event(Event$3.HIDE);
1396 $(this._element).trigger(startEvent);
1397
1398 if (startEvent.isDefaultPrevented()) {
1399 return;
1400 }
1401
1402 var dimension = this._getDimension();
1403
1404 this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px";
1405 Util.reflow(this._element);
1406 $(this._element).addClass(ClassName$3.COLLAPSING).removeClass(ClassName$3.COLLAPSE).removeClass(ClassName$3.SHOW);
1407 var triggerArrayLength = this._triggerArray.length;
1408
1409 if (triggerArrayLength > 0) {
1410 for (var i = 0; i < triggerArrayLength; i++) {
1411 var trigger = this._triggerArray[i];
1412 var selector = Util.getSelectorFromElement(trigger);
1413
1414 if (selector !== null) {
1415 var $elem = $([].slice.call(document.querySelectorAll(selector)));
1416
1417 if (!$elem.hasClass(ClassName$3.SHOW)) {
1418 $(trigger).addClass(ClassName$3.COLLAPSED).attr('aria-expanded', false);
1419 }
1420 }
1421 }
1422 }
1423
1424 this.setTransitioning(true);
1425
1426 var complete = function complete() {
1427 _this2.setTransitioning(false);
1428
1429 $(_this2._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).trigger(Event$3.HIDDEN);
1430 };
1431
1432 this._element.style[dimension] = '';
1433 var transitionDuration = Util.getTransitionDurationFromElement(this._element);
1434 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
1435 };
1436
1437 _proto.setTransitioning = function setTransitioning(isTransitioning) {
1438 this._isTransitioning = isTransitioning;
1439 };
1440
1441 _proto.dispose = function dispose() {
1442 $.removeData(this._element, DATA_KEY$3);
1443 this._config = null;
1444 this._parent = null;
1445 this._element = null;
1446 this._triggerArray = null;
1447 this._isTransitioning = null;
1448 } // Private
1449 ;
1450
1451 _proto._getConfig = function _getConfig(config) {
1452 config = _objectSpread2({}, Default$1, {}, config);
1453 config.toggle = Boolean(config.toggle); // Coerce string values
1454
1455 Util.typeCheckConfig(NAME$3, config, DefaultType$1);
1456 return config;
1457 };
1458
1459 _proto._getDimension = function _getDimension() {
1460 var hasWidth = $(this._element).hasClass(Dimension.WIDTH);
1461 return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT;
1462 };
1463
1464 _proto._getParent = function _getParent() {
1465 var _this3 = this;
1466
1467 var parent;
1468
1469 if (Util.isElement(this._config.parent)) {
1470 parent = this._config.parent; // It's a jQuery object
1471
1472 if (typeof this._config.parent.jquery !== 'undefined') {
1473 parent = this._config.parent[0];
1474 }
1475 } else {
1476 parent = document.querySelector(this._config.parent);
1477 }
1478
1479 var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]";
1480 var children = [].slice.call(parent.querySelectorAll(selector));
1481 $(children).each(function (i, element) {
1482 _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]);
1483 });
1484 return parent;
1485 };
1486
1487 _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
1488 var isOpen = $(element).hasClass(ClassName$3.SHOW);
1489
1490 if (triggerArray.length) {
1491 $(triggerArray).toggleClass(ClassName$3.COLLAPSED, !isOpen).attr('aria-expanded', isOpen);
1492 }
1493 } // Static
1494 ;
1495
1496 Collapse._getTargetFromElement = function _getTargetFromElement(element) {
1497 var selector = Util.getSelectorFromElement(element);
1498 return selector ? document.querySelector(selector) : null;
1499 };
1500
1501 Collapse._jQueryInterface = function _jQueryInterface(config) {
1502 return this.each(function () {
1503 var $this = $(this);
1504 var data = $this.data(DATA_KEY$3);
1505
1506 var _config = _objectSpread2({}, Default$1, {}, $this.data(), {}, typeof config === 'object' && config ? config : {});
1507
1508 if (!data && _config.toggle && /show|hide/.test(config)) {
1509 _config.toggle = false;
1510 }
1511
1512 if (!data) {
1513 data = new Collapse(this, _config);
1514 $this.data(DATA_KEY$3, data);
1515 }
1516
1517 if (typeof config === 'string') {
1518 if (typeof data[config] === 'undefined') {
1519 throw new TypeError("No method named \"" + config + "\"");
1520 }
1521
1522 data[config]();
1523 }
1524 });
1525 };
1526
1527 _createClass(Collapse, null, [{
1528 key: "VERSION",
1529 get: function get() {
1530 return VERSION$3;
1531 }
1532 }, {
1533 key: "Default",
1534 get: function get() {
1535 return Default$1;
1536 }
1537 }]);
1538
1539 return Collapse;
1540 }();
1541 /**
1542 * ------------------------------------------------------------------------
1543 * Data Api implementation
1544 * ------------------------------------------------------------------------
1545 */
1546
1547
1548 $(document).on(Event$3.CLICK_DATA_API, Selector$3.DATA_TOGGLE, function (event) {
1549 // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
1550 if (event.currentTarget.tagName === 'A') {
1551 event.preventDefault();
1552 }
1553
1554 var $trigger = $(this);
1555 var selector = Util.getSelectorFromElement(this);
1556 var selectors = [].slice.call(document.querySelectorAll(selector));
1557 $(selectors).each(function () {
1558 var $target = $(this);
1559 var data = $target.data(DATA_KEY$3);
1560 var config = data ? 'toggle' : $trigger.data();
1561
1562 Collapse._jQueryInterface.call($target, config);
1563 });
1564 });
1565 /**
1566 * ------------------------------------------------------------------------
1567 * jQuery
1568 * ------------------------------------------------------------------------
1569 */
1570
1571 $.fn[NAME$3] = Collapse._jQueryInterface;
1572 $.fn[NAME$3].Constructor = Collapse;
1573
1574 $.fn[NAME$3].noConflict = function () {
1575 $.fn[NAME$3] = JQUERY_NO_CONFLICT$3;
1576 return Collapse._jQueryInterface;
1577 };
1578
1579 /**!
1580 * @fileOverview Kickass library to create and place poppers near their reference elements.
1581 * @version 1.16.0
1582 * @license
1583 * Copyright (c) 2016 Federico Zivolo and contributors
1584 *
1585 * Permission is hereby granted, free of charge, to any person obtaining a copy
1586 * of this software and associated documentation files (the "Software"), to deal
1587 * in the Software without restriction, including without limitation the rights
1588 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
1589 * copies of the Software, and to permit persons to whom the Software is
1590 * furnished to do so, subject to the following conditions:
1591 *
1592 * The above copyright notice and this permission notice shall be included in all
1593 * copies or substantial portions of the Software.
1594 *
1595 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1596 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1597 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1598 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
1599 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
1600 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
1601 * SOFTWARE.
1602 */
1603 var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';
1604
1605 var timeoutDuration = function () {
1606 var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
1607 for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
1608 if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
1609 return 1;
1610 }
1611 }
1612 return 0;
1613 }();
1614
1615 function microtaskDebounce(fn) {
1616 var called = false;
1617 return function () {
1618 if (called) {
1619 return;
1620 }
1621 called = true;
1622 window.Promise.resolve().then(function () {
1623 called = false;
1624 fn();
1625 });
1626 };
1627 }
1628
1629 function taskDebounce(fn) {
1630 var scheduled = false;
1631 return function () {
1632 if (!scheduled) {
1633 scheduled = true;
1634 setTimeout(function () {
1635 scheduled = false;
1636 fn();
1637 }, timeoutDuration);
1638 }
1639 };
1640 }
1641
1642 var supportsMicroTasks = isBrowser && window.Promise;
1643
1644 /**
1645 * Create a debounced version of a method, that's asynchronously deferred
1646 * but called in the minimum time possible.
1647 *
1648 * @method
1649 * @memberof Popper.Utils
1650 * @argument {Function} fn
1651 * @returns {Function}
1652 */
1653 var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
1654
1655 /**
1656 * Check if the given variable is a function
1657 * @method
1658 * @memberof Popper.Utils
1659 * @argument {Any} functionToCheck - variable to check
1660 * @returns {Boolean} answer to: is a function?
1661 */
1662 function isFunction(functionToCheck) {
1663 var getType = {};
1664 return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
1665 }
1666
1667 /**
1668 * Get CSS computed property of the given element
1669 * @method
1670 * @memberof Popper.Utils
1671 * @argument {Eement} element
1672 * @argument {String} property
1673 */
1674 function getStyleComputedProperty(element, property) {
1675 if (element.nodeType !== 1) {
1676 return [];
1677 }
1678 // NOTE: 1 DOM access here
1679 var window = element.ownerDocument.defaultView;
1680 var css = window.getComputedStyle(element, null);
1681 return property ? css[property] : css;
1682 }
1683
1684 /**
1685 * Returns the parentNode or the host of the element
1686 * @method
1687 * @memberof Popper.Utils
1688 * @argument {Element} element
1689 * @returns {Element} parent
1690 */
1691 function getParentNode(element) {
1692 if (element.nodeName === 'HTML') {
1693 return element;
1694 }
1695 return element.parentNode || element.host;
1696 }
1697
1698 /**
1699 * Returns the scrolling parent of the given element
1700 * @method
1701 * @memberof Popper.Utils
1702 * @argument {Element} element
1703 * @returns {Element} scroll parent
1704 */
1705 function getScrollParent(element) {
1706 // Return body, `getScroll` will take care to get the correct `scrollTop` from it
1707 if (!element) {
1708 return document.body;
1709 }
1710
1711 switch (element.nodeName) {
1712 case 'HTML':
1713 case 'BODY':
1714 return element.ownerDocument.body;
1715 case '#document':
1716 return element.body;
1717 }
1718
1719 // Firefox want us to check `-x` and `-y` variations as well
1720
1721 var _getStyleComputedProp = getStyleComputedProperty(element),
1722 overflow = _getStyleComputedProp.overflow,
1723 overflowX = _getStyleComputedProp.overflowX,
1724 overflowY = _getStyleComputedProp.overflowY;
1725
1726 if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
1727 return element;
1728 }
1729
1730 return getScrollParent(getParentNode(element));
1731 }
1732
1733 /**
1734 * Returns the reference node of the reference object, or the reference object itself.
1735 * @method
1736 * @memberof Popper.Utils
1737 * @param {Element|Object} reference - the reference element (the popper will be relative to this)
1738 * @returns {Element} parent
1739 */
1740 function getReferenceNode(reference) {
1741 return reference && reference.referenceNode ? reference.referenceNode : reference;
1742 }
1743
1744 var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
1745 var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
1746
1747 /**
1748 * Determines if the browser is Internet Explorer
1749 * @method
1750 * @memberof Popper.Utils
1751 * @param {Number} version to check
1752 * @returns {Boolean} isIE
1753 */
1754 function isIE(version) {
1755 if (version === 11) {
1756 return isIE11;
1757 }
1758 if (version === 10) {
1759 return isIE10;
1760 }
1761 return isIE11 || isIE10;
1762 }
1763
1764 /**
1765 * Returns the offset parent of the given element
1766 * @method
1767 * @memberof Popper.Utils
1768 * @argument {Element} element
1769 * @returns {Element} offset parent
1770 */
1771 function getOffsetParent(element) {
1772 if (!element) {
1773 return document.documentElement;
1774 }
1775
1776 var noOffsetParent = isIE(10) ? document.body : null;
1777
1778 // NOTE: 1 DOM access here
1779 var offsetParent = element.offsetParent || null;
1780 // Skip hidden elements which don't have an offsetParent
1781 while (offsetParent === noOffsetParent && element.nextElementSibling) {
1782 offsetParent = (element = element.nextElementSibling).offsetParent;
1783 }
1784
1785 var nodeName = offsetParent && offsetParent.nodeName;
1786
1787 if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
1788 return element ? element.ownerDocument.documentElement : document.documentElement;
1789 }
1790
1791 // .offsetParent will return the closest TH, TD or TABLE in case
1792 // no offsetParent is present, I hate this job...
1793 if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
1794 return getOffsetParent(offsetParent);
1795 }
1796
1797 return offsetParent;
1798 }
1799
1800 function isOffsetContainer(element) {
1801 var nodeName = element.nodeName;
1802
1803 if (nodeName === 'BODY') {
1804 return false;
1805 }
1806 return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
1807 }
1808
1809 /**
1810 * Finds the root node (document, shadowDOM root) of the given element
1811 * @method
1812 * @memberof Popper.Utils
1813 * @argument {Element} node
1814 * @returns {Element} root node
1815 */
1816 function getRoot(node) {
1817 if (node.parentNode !== null) {
1818 return getRoot(node.parentNode);
1819 }
1820
1821 return node;
1822 }
1823
1824 /**
1825 * Finds the offset parent common to the two provided nodes
1826 * @method
1827 * @memberof Popper.Utils
1828 * @argument {Element} element1
1829 * @argument {Element} element2
1830 * @returns {Element} common offset parent
1831 */
1832 function findCommonOffsetParent(element1, element2) {
1833 // This check is needed to avoid errors in case one of the elements isn't defined for any reason
1834 if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
1835 return document.documentElement;
1836 }
1837
1838 // Here we make sure to give as "start" the element that comes first in the DOM
1839 var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
1840 var start = order ? element1 : element2;
1841 var end = order ? element2 : element1;
1842
1843 // Get common ancestor container
1844 var range = document.createRange();
1845 range.setStart(start, 0);
1846 range.setEnd(end, 0);
1847 var commonAncestorContainer = range.commonAncestorContainer;
1848
1849 // Both nodes are inside #document
1850
1851 if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
1852 if (isOffsetContainer(commonAncestorContainer)) {
1853 return commonAncestorContainer;
1854 }
1855
1856 return getOffsetParent(commonAncestorContainer);
1857 }
1858
1859 // one of the nodes is inside shadowDOM, find which one
1860 var element1root = getRoot(element1);
1861 if (element1root.host) {
1862 return findCommonOffsetParent(element1root.host, element2);
1863 } else {
1864 return findCommonOffsetParent(element1, getRoot(element2).host);
1865 }
1866 }
1867
1868 /**
1869 * Gets the scroll value of the given element in the given side (top and left)
1870 * @method
1871 * @memberof Popper.Utils
1872 * @argument {Element} element
1873 * @argument {String} side `top` or `left`
1874 * @returns {number} amount of scrolled pixels
1875 */
1876 function getScroll(element) {
1877 var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
1878
1879 var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
1880 var nodeName = element.nodeName;
1881
1882 if (nodeName === 'BODY' || nodeName === 'HTML') {
1883 var html = element.ownerDocument.documentElement;
1884 var scrollingElement = element.ownerDocument.scrollingElement || html;
1885 return scrollingElement[upperSide];
1886 }
1887
1888 return element[upperSide];
1889 }
1890
1891 /*
1892 * Sum or subtract the element scroll values (left and top) from a given rect object
1893 * @method
1894 * @memberof Popper.Utils
1895 * @param {Object} rect - Rect object you want to change
1896 * @param {HTMLElement} element - The element from the function reads the scroll values
1897 * @param {Boolean} subtract - set to true if you want to subtract the scroll values
1898 * @return {Object} rect - The modifier rect object
1899 */
1900 function includeScroll(rect, element) {
1901 var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
1902
1903 var scrollTop = getScroll(element, 'top');
1904 var scrollLeft = getScroll(element, 'left');
1905 var modifier = subtract ? -1 : 1;
1906 rect.top += scrollTop * modifier;
1907 rect.bottom += scrollTop * modifier;
1908 rect.left += scrollLeft * modifier;
1909 rect.right += scrollLeft * modifier;
1910 return rect;
1911 }
1912
1913 /*
1914 * Helper to detect borders of a given element
1915 * @method
1916 * @memberof Popper.Utils
1917 * @param {CSSStyleDeclaration} styles
1918 * Result of `getStyleComputedProperty` on the given element
1919 * @param {String} axis - `x` or `y`
1920 * @return {number} borders - The borders size of the given axis
1921 */
1922
1923 function getBordersSize(styles, axis) {
1924 var sideA = axis === 'x' ? 'Left' : 'Top';
1925 var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
1926
1927 return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10);
1928 }
1929
1930 function getSize(axis, body, html, computedStyle) {
1931 return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0);
1932 }
1933
1934 function getWindowSizes(document) {
1935 var body = document.body;
1936 var html = document.documentElement;
1937 var computedStyle = isIE(10) && getComputedStyle(html);
1938
1939 return {
1940 height: getSize('Height', body, html, computedStyle),
1941 width: getSize('Width', body, html, computedStyle)
1942 };
1943 }
1944
1945 var classCallCheck = function (instance, Constructor) {
1946 if (!(instance instanceof Constructor)) {
1947 throw new TypeError("Cannot call a class as a function");
1948 }
1949 };
1950
1951 var createClass = function () {
1952 function defineProperties(target, props) {
1953 for (var i = 0; i < props.length; i++) {
1954 var descriptor = props[i];
1955 descriptor.enumerable = descriptor.enumerable || false;
1956 descriptor.configurable = true;
1957 if ("value" in descriptor) descriptor.writable = true;
1958 Object.defineProperty(target, descriptor.key, descriptor);
1959 }
1960 }
1961
1962 return function (Constructor, protoProps, staticProps) {
1963 if (protoProps) defineProperties(Constructor.prototype, protoProps);
1964 if (staticProps) defineProperties(Constructor, staticProps);
1965 return Constructor;
1966 };
1967 }();
1968
1969
1970
1971
1972
1973 var defineProperty = function (obj, key, value) {
1974 if (key in obj) {
1975 Object.defineProperty(obj, key, {
1976 value: value,
1977 enumerable: true,
1978 configurable: true,
1979 writable: true
1980 });
1981 } else {
1982 obj[key] = value;
1983 }
1984
1985 return obj;
1986 };
1987
1988 var _extends = Object.assign || function (target) {
1989 for (var i = 1; i < arguments.length; i++) {
1990 var source = arguments[i];
1991
1992 for (var key in source) {
1993 if (Object.prototype.hasOwnProperty.call(source, key)) {
1994 target[key] = source[key];
1995 }
1996 }
1997 }
1998
1999 return target;
2000 };
2001
2002 /**
2003 * Given element offsets, generate an output similar to getBoundingClientRect
2004 * @method
2005 * @memberof Popper.Utils
2006 * @argument {Object} offsets
2007 * @returns {Object} ClientRect like output
2008 */
2009 function getClientRect(offsets) {
2010 return _extends({}, offsets, {
2011 right: offsets.left + offsets.width,
2012 bottom: offsets.top + offsets.height
2013 });
2014 }
2015
2016 /**
2017 * Get bounding client rect of given element
2018 * @method
2019 * @memberof Popper.Utils
2020 * @param {HTMLElement} element
2021 * @return {Object} client rect
2022 */
2023 function getBoundingClientRect(element) {
2024 var rect = {};
2025
2026 // IE10 10 FIX: Please, don't ask, the element isn't
2027 // considered in DOM in some circumstances...
2028 // This isn't reproducible in IE10 compatibility mode of IE11
2029 try {
2030 if (isIE(10)) {
2031 rect = element.getBoundingClientRect();
2032 var scrollTop = getScroll(element, 'top');
2033 var scrollLeft = getScroll(element, 'left');
2034 rect.top += scrollTop;
2035 rect.left += scrollLeft;
2036 rect.bottom += scrollTop;
2037 rect.right += scrollLeft;
2038 } else {
2039 rect = element.getBoundingClientRect();
2040 }
2041 } catch (e) {}
2042
2043 var result = {
2044 left: rect.left,
2045 top: rect.top,
2046 width: rect.right - rect.left,
2047 height: rect.bottom - rect.top
2048 };
2049
2050 // subtract scrollbar size from sizes
2051 var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};
2052 var width = sizes.width || element.clientWidth || result.width;
2053 var height = sizes.height || element.clientHeight || result.height;
2054
2055 var horizScrollbar = element.offsetWidth - width;
2056 var vertScrollbar = element.offsetHeight - height;
2057
2058 // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
2059 // we make this check conditional for performance reasons
2060 if (horizScrollbar || vertScrollbar) {
2061 var styles = getStyleComputedProperty(element);
2062 horizScrollbar -= getBordersSize(styles, 'x');
2063 vertScrollbar -= getBordersSize(styles, 'y');
2064
2065 result.width -= horizScrollbar;
2066 result.height -= vertScrollbar;
2067 }
2068
2069 return getClientRect(result);
2070 }
2071
2072 function getOffsetRectRelativeToArbitraryNode(children, parent) {
2073 var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
2074
2075 var isIE10 = isIE(10);
2076 var isHTML = parent.nodeName === 'HTML';
2077 var childrenRect = getBoundingClientRect(children);
2078 var parentRect = getBoundingClientRect(parent);
2079 var scrollParent = getScrollParent(children);
2080
2081 var styles = getStyleComputedProperty(parent);
2082 var borderTopWidth = parseFloat(styles.borderTopWidth, 10);
2083 var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10);
2084
2085 // In cases where the parent is fixed, we must ignore negative scroll in offset calc
2086 if (fixedPosition && isHTML) {
2087 parentRect.top = Math.max(parentRect.top, 0);
2088 parentRect.left = Math.max(parentRect.left, 0);
2089 }
2090 var offsets = getClientRect({
2091 top: childrenRect.top - parentRect.top - borderTopWidth,
2092 left: childrenRect.left - parentRect.left - borderLeftWidth,
2093 width: childrenRect.width,
2094 height: childrenRect.height
2095 });
2096 offsets.marginTop = 0;
2097 offsets.marginLeft = 0;
2098
2099 // Subtract margins of documentElement in case it's being used as parent
2100 // we do this only on HTML because it's the only element that behaves
2101 // differently when margins are applied to it. The margins are included in
2102 // the box of the documentElement, in the other cases not.
2103 if (!isIE10 && isHTML) {
2104 var marginTop = parseFloat(styles.marginTop, 10);
2105 var marginLeft = parseFloat(styles.marginLeft, 10);
2106
2107 offsets.top -= borderTopWidth - marginTop;
2108 offsets.bottom -= borderTopWidth - marginTop;
2109 offsets.left -= borderLeftWidth - marginLeft;
2110 offsets.right -= borderLeftWidth - marginLeft;
2111
2112 // Attach marginTop and marginLeft because in some circumstances we may need them
2113 offsets.marginTop = marginTop;
2114 offsets.marginLeft = marginLeft;
2115 }
2116
2117 if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
2118 offsets = includeScroll(offsets, parent);
2119 }
2120
2121 return offsets;
2122 }
2123
2124 function getViewportOffsetRectRelativeToArtbitraryNode(element) {
2125 var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
2126
2127 var html = element.ownerDocument.documentElement;
2128 var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
2129 var width = Math.max(html.clientWidth, window.innerWidth || 0);
2130 var height = Math.max(html.clientHeight, window.innerHeight || 0);
2131
2132 var scrollTop = !excludeScroll ? getScroll(html) : 0;
2133 var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;
2134
2135 var offset = {
2136 top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
2137 left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
2138 width: width,
2139 height: height
2140 };
2141
2142 return getClientRect(offset);
2143 }
2144
2145 /**
2146 * Check if the given element is fixed or is inside a fixed parent
2147 * @method
2148 * @memberof Popper.Utils
2149 * @argument {Element} element
2150 * @argument {Element} customContainer
2151 * @returns {Boolean} answer to "isFixed?"
2152 */
2153 function isFixed(element) {
2154 var nodeName = element.nodeName;
2155 if (nodeName === 'BODY' || nodeName === 'HTML') {
2156 return false;
2157 }
2158 if (getStyleComputedProperty(element, 'position') === 'fixed') {
2159 return true;
2160 }
2161 var parentNode = getParentNode(element);
2162 if (!parentNode) {
2163 return false;
2164 }
2165 return isFixed(parentNode);
2166 }
2167
2168 /**
2169 * Finds the first parent of an element that has a transformed property defined
2170 * @method
2171 * @memberof Popper.Utils
2172 * @argument {Element} element
2173 * @returns {Element} first transformed parent or documentElement
2174 */
2175
2176 function getFixedPositionOffsetParent(element) {
2177 // This check is needed to avoid errors in case one of the elements isn't defined for any reason
2178 if (!element || !element.parentElement || isIE()) {
2179 return document.documentElement;
2180 }
2181 var el = element.parentElement;
2182 while (el && getStyleComputedProperty(el, 'transform') === 'none') {
2183 el = el.parentElement;
2184 }
2185 return el || document.documentElement;
2186 }
2187
2188 /**
2189 * Computed the boundaries limits and return them
2190 * @method
2191 * @memberof Popper.Utils
2192 * @param {HTMLElement} popper
2193 * @param {HTMLElement} reference
2194 * @param {number} padding
2195 * @param {HTMLElement} boundariesElement - Element used to define the boundaries
2196 * @param {Boolean} fixedPosition - Is in fixed position mode
2197 * @returns {Object} Coordinates of the boundaries
2198 */
2199 function getBoundaries(popper, reference, padding, boundariesElement) {
2200 var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
2201
2202 // NOTE: 1 DOM access here
2203
2204 var boundaries = { top: 0, left: 0 };
2205 var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
2206
2207 // Handle viewport case
2208 if (boundariesElement === 'viewport') {
2209 boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
2210 } else {
2211 // Handle other cases based on DOM element used as boundaries
2212 var boundariesNode = void 0;
2213 if (boundariesElement === 'scrollParent') {
2214 boundariesNode = getScrollParent(getParentNode(reference));
2215 if (boundariesNode.nodeName === 'BODY') {
2216 boundariesNode = popper.ownerDocument.documentElement;
2217 }
2218 } else if (boundariesElement === 'window') {
2219 boundariesNode = popper.ownerDocument.documentElement;
2220 } else {
2221 boundariesNode = boundariesElement;
2222 }
2223
2224 var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
2225
2226 // In case of HTML, we need a different computation
2227 if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
2228 var _getWindowSizes = getWindowSizes(popper.ownerDocument),
2229 height = _getWindowSizes.height,
2230 width = _getWindowSizes.width;
2231
2232 boundaries.top += offsets.top - offsets.marginTop;
2233 boundaries.bottom = height + offsets.top;
2234 boundaries.left += offsets.left - offsets.marginLeft;
2235 boundaries.right = width + offsets.left;
2236 } else {
2237 // for all the other DOM elements, this one is good
2238 boundaries = offsets;
2239 }
2240 }
2241
2242 // Add paddings
2243 padding = padding || 0;
2244 var isPaddingNumber = typeof padding === 'number';
2245 boundaries.left += isPaddingNumber ? padding : padding.left || 0;
2246 boundaries.top += isPaddingNumber ? padding : padding.top || 0;
2247 boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
2248 boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
2249
2250 return boundaries;
2251 }
2252
2253 function getArea(_ref) {
2254 var width = _ref.width,
2255 height = _ref.height;
2256
2257 return width * height;
2258 }
2259
2260 /**
2261 * Utility used to transform the `auto` placement to the placement with more
2262 * available space.
2263 * @method
2264 * @memberof Popper.Utils
2265 * @argument {Object} data - The data object generated by update method
2266 * @argument {Object} options - Modifiers configuration and options
2267 * @returns {Object} The data object, properly modified
2268 */
2269 function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
2270 var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
2271
2272 if (placement.indexOf('auto') === -1) {
2273 return placement;
2274 }
2275
2276 var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
2277
2278 var rects = {
2279 top: {
2280 width: boundaries.width,
2281 height: refRect.top - boundaries.top
2282 },
2283 right: {
2284 width: boundaries.right - refRect.right,
2285 height: boundaries.height
2286 },
2287 bottom: {
2288 width: boundaries.width,
2289 height: boundaries.bottom - refRect.bottom
2290 },
2291 left: {
2292 width: refRect.left - boundaries.left,
2293 height: boundaries.height
2294 }
2295 };
2296
2297 var sortedAreas = Object.keys(rects).map(function (key) {
2298 return _extends({
2299 key: key
2300 }, rects[key], {
2301 area: getArea(rects[key])
2302 });
2303 }).sort(function (a, b) {
2304 return b.area - a.area;
2305 });
2306
2307 var filteredAreas = sortedAreas.filter(function (_ref2) {
2308 var width = _ref2.width,
2309 height = _ref2.height;
2310 return width >= popper.clientWidth && height >= popper.clientHeight;
2311 });
2312
2313 var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
2314
2315 var variation = placement.split('-')[1];
2316
2317 return computedPlacement + (variation ? '-' + variation : '');
2318 }
2319
2320 /**
2321 * Get offsets to the reference element
2322 * @method
2323 * @memberof Popper.Utils
2324 * @param {Object} state
2325 * @param {Element} popper - the popper element
2326 * @param {Element} reference - the reference element (the popper will be relative to this)
2327 * @param {Element} fixedPosition - is in fixed position mode
2328 * @returns {Object} An object containing the offsets which will be applied to the popper
2329 */
2330 function getReferenceOffsets(state, popper, reference) {
2331 var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
2332
2333 var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
2334 return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
2335 }
2336
2337 /**
2338 * Get the outer sizes of the given element (offset size + margins)
2339 * @method
2340 * @memberof Popper.Utils
2341 * @argument {Element} element
2342 * @returns {Object} object containing width and height properties
2343 */
2344 function getOuterSizes(element) {
2345 var window = element.ownerDocument.defaultView;
2346 var styles = window.getComputedStyle(element);
2347 var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
2348 var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
2349 var result = {
2350 width: element.offsetWidth + y,
2351 height: element.offsetHeight + x
2352 };
2353 return result;
2354 }
2355
2356 /**
2357 * Get the opposite placement of the given one
2358 * @method
2359 * @memberof Popper.Utils
2360 * @argument {String} placement
2361 * @returns {String} flipped placement
2362 */
2363 function getOppositePlacement(placement) {
2364 var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
2365 return placement.replace(/left|right|bottom|top/g, function (matched) {
2366 return hash[matched];
2367 });
2368 }
2369
2370 /**
2371 * Get offsets to the popper
2372 * @method
2373 * @memberof Popper.Utils
2374 * @param {Object} position - CSS position the Popper will get applied
2375 * @param {HTMLElement} popper - the popper element
2376 * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
2377 * @param {String} placement - one of the valid placement options
2378 * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
2379 */
2380 function getPopperOffsets(popper, referenceOffsets, placement) {
2381 placement = placement.split('-')[0];
2382
2383 // Get popper node sizes
2384 var popperRect = getOuterSizes(popper);
2385
2386 // Add position, width and height to our offsets object
2387 var popperOffsets = {
2388 width: popperRect.width,
2389 height: popperRect.height
2390 };
2391
2392 // depending by the popper placement we have to compute its offsets slightly differently
2393 var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
2394 var mainSide = isHoriz ? 'top' : 'left';
2395 var secondarySide = isHoriz ? 'left' : 'top';
2396 var measurement = isHoriz ? 'height' : 'width';
2397 var secondaryMeasurement = !isHoriz ? 'height' : 'width';
2398
2399 popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
2400 if (placement === secondarySide) {
2401 popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
2402 } else {
2403 popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
2404 }
2405
2406 return popperOffsets;
2407 }
2408
2409 /**
2410 * Mimics the `find` method of Array
2411 * @method
2412 * @memberof Popper.Utils
2413 * @argument {Array} arr
2414 * @argument prop
2415 * @argument value
2416 * @returns index or -1
2417 */
2418 function find(arr, check) {
2419 // use native find if supported
2420 if (Array.prototype.find) {
2421 return arr.find(check);
2422 }
2423
2424 // use `filter` to obtain the same behavior of `find`
2425 return arr.filter(check)[0];
2426 }
2427
2428 /**
2429 * Return the index of the matching object
2430 * @method
2431 * @memberof Popper.Utils
2432 * @argument {Array} arr
2433 * @argument prop
2434 * @argument value
2435 * @returns index or -1
2436 */
2437 function findIndex(arr, prop, value) {
2438 // use native findIndex if supported
2439 if (Array.prototype.findIndex) {
2440 return arr.findIndex(function (cur) {
2441 return cur[prop] === value;
2442 });
2443 }
2444
2445 // use `find` + `indexOf` if `findIndex` isn't supported
2446 var match = find(arr, function (obj) {
2447 return obj[prop] === value;
2448 });
2449 return arr.indexOf(match);
2450 }
2451
2452 /**
2453 * Loop trough the list of modifiers and run them in order,
2454 * each of them will then edit the data object.
2455 * @method
2456 * @memberof Popper.Utils
2457 * @param {dataObject} data
2458 * @param {Array} modifiers
2459 * @param {String} ends - Optional modifier name used as stopper
2460 * @returns {dataObject}
2461 */
2462 function runModifiers(modifiers, data, ends) {
2463 var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
2464
2465 modifiersToRun.forEach(function (modifier) {
2466 if (modifier['function']) {
2467 // eslint-disable-line dot-notation
2468 console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
2469 }
2470 var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
2471 if (modifier.enabled && isFunction(fn)) {
2472 // Add properties to offsets to make them a complete clientRect object
2473 // we do this before each modifier to make sure the previous one doesn't
2474 // mess with these values
2475 data.offsets.popper = getClientRect(data.offsets.popper);
2476 data.offsets.reference = getClientRect(data.offsets.reference);
2477
2478 data = fn(data, modifier);
2479 }
2480 });
2481
2482 return data;
2483 }
2484
2485 /**
2486 * Updates the position of the popper, computing the new offsets and applying
2487 * the new style.<br />
2488 * Prefer `scheduleUpdate` over `update` because of performance reasons.
2489 * @method
2490 * @memberof Popper
2491 */
2492 function update() {
2493 // if popper is destroyed, don't perform any further update
2494 if (this.state.isDestroyed) {
2495 return;
2496 }
2497
2498 var data = {
2499 instance: this,
2500 styles: {},
2501 arrowStyles: {},
2502 attributes: {},
2503 flipped: false,
2504 offsets: {}
2505 };
2506
2507 // compute reference element offsets
2508 data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);
2509
2510 // compute auto placement, store placement inside the data object,
2511 // modifiers will be able to edit `placement` if needed
2512 // and refer to originalPlacement to know the original value
2513 data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
2514
2515 // store the computed placement inside `originalPlacement`
2516 data.originalPlacement = data.placement;
2517
2518 data.positionFixed = this.options.positionFixed;
2519
2520 // compute the popper offsets
2521 data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
2522
2523 data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';
2524
2525 // run the modifiers
2526 data = runModifiers(this.modifiers, data);
2527
2528 // the first `update` will call `onCreate` callback
2529 // the other ones will call `onUpdate` callback
2530 if (!this.state.isCreated) {
2531 this.state.isCreated = true;
2532 this.options.onCreate(data);
2533 } else {
2534 this.options.onUpdate(data);
2535 }
2536 }
2537
2538 /**
2539 * Helper used to know if the given modifier is enabled.
2540 * @method
2541 * @memberof Popper.Utils
2542 * @returns {Boolean}
2543 */
2544 function isModifierEnabled(modifiers, modifierName) {
2545 return modifiers.some(function (_ref) {
2546 var name = _ref.name,
2547 enabled = _ref.enabled;
2548 return enabled && name === modifierName;
2549 });
2550 }
2551
2552 /**
2553 * Get the prefixed supported property name
2554 * @method
2555 * @memberof Popper.Utils
2556 * @argument {String} property (camelCase)
2557 * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
2558 */
2559 function getSupportedPropertyName(property) {
2560 var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
2561 var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
2562
2563 for (var i = 0; i < prefixes.length; i++) {
2564 var prefix = prefixes[i];
2565 var toCheck = prefix ? '' + prefix + upperProp : property;
2566 if (typeof document.body.style[toCheck] !== 'undefined') {
2567 return toCheck;
2568 }
2569 }
2570 return null;
2571 }
2572
2573 /**
2574 * Destroys the popper.
2575 * @method
2576 * @memberof Popper
2577 */
2578 function destroy() {
2579 this.state.isDestroyed = true;
2580
2581 // touch DOM only if `applyStyle` modifier is enabled
2582 if (isModifierEnabled(this.modifiers, 'applyStyle')) {
2583 this.popper.removeAttribute('x-placement');
2584 this.popper.style.position = '';
2585 this.popper.style.top = '';
2586 this.popper.style.left = '';
2587 this.popper.style.right = '';
2588 this.popper.style.bottom = '';
2589 this.popper.style.willChange = '';
2590 this.popper.style[getSupportedPropertyName('transform')] = '';
2591 }
2592
2593 this.disableEventListeners();
2594
2595 // remove the popper if user explicitly asked for the deletion on destroy
2596 // do not use `remove` because IE11 doesn't support it
2597 if (this.options.removeOnDestroy) {
2598 this.popper.parentNode.removeChild(this.popper);
2599 }
2600 return this;
2601 }
2602
2603 /**
2604 * Get the window associated with the element
2605 * @argument {Element} element
2606 * @returns {Window}
2607 */
2608 function getWindow(element) {
2609 var ownerDocument = element.ownerDocument;
2610 return ownerDocument ? ownerDocument.defaultView : window;
2611 }
2612
2613 function attachToScrollParents(scrollParent, event, callback, scrollParents) {
2614 var isBody = scrollParent.nodeName === 'BODY';
2615 var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
2616 target.addEventListener(event, callback, { passive: true });
2617
2618 if (!isBody) {
2619 attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
2620 }
2621 scrollParents.push(target);
2622 }
2623
2624 /**
2625 * Setup needed event listeners used to update the popper position
2626 * @method
2627 * @memberof Popper.Utils
2628 * @private
2629 */
2630 function setupEventListeners(reference, options, state, updateBound) {
2631 // Resize event listener on window
2632 state.updateBound = updateBound;
2633 getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });
2634
2635 // Scroll event listener on scroll parents
2636 var scrollElement = getScrollParent(reference);
2637 attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
2638 state.scrollElement = scrollElement;
2639 state.eventsEnabled = true;
2640
2641 return state;
2642 }
2643
2644 /**
2645 * It will add resize/scroll events and start recalculating
2646 * position of the popper element when they are triggered.
2647 * @method
2648 * @memberof Popper
2649 */
2650 function enableEventListeners() {
2651 if (!this.state.eventsEnabled) {
2652 this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
2653 }
2654 }
2655
2656 /**
2657 * Remove event listeners used to update the popper position
2658 * @method
2659 * @memberof Popper.Utils
2660 * @private
2661 */
2662 function removeEventListeners(reference, state) {
2663 // Remove resize event listener on window
2664 getWindow(reference).removeEventListener('resize', state.updateBound);
2665
2666 // Remove scroll event listener on scroll parents
2667 state.scrollParents.forEach(function (target) {
2668 target.removeEventListener('scroll', state.updateBound);
2669 });
2670
2671 // Reset state
2672 state.updateBound = null;
2673 state.scrollParents = [];
2674 state.scrollElement = null;
2675 state.eventsEnabled = false;
2676 return state;
2677 }
2678
2679 /**
2680 * It will remove resize/scroll events and won't recalculate popper position
2681 * when they are triggered. It also won't trigger `onUpdate` callback anymore,
2682 * unless you call `update` method manually.
2683 * @method
2684 * @memberof Popper
2685 */
2686 function disableEventListeners() {
2687 if (this.state.eventsEnabled) {
2688 cancelAnimationFrame(this.scheduleUpdate);
2689 this.state = removeEventListeners(this.reference, this.state);
2690 }
2691 }
2692
2693 /**
2694 * Tells if a given input is a number
2695 * @method
2696 * @memberof Popper.Utils
2697 * @param {*} input to check
2698 * @return {Boolean}
2699 */
2700 function isNumeric(n) {
2701 return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
2702 }
2703
2704 /**
2705 * Set the style to the given popper
2706 * @method
2707 * @memberof Popper.Utils
2708 * @argument {Element} element - Element to apply the style to
2709 * @argument {Object} styles
2710 * Object with a list of properties and values which will be applied to the element
2711 */
2712 function setStyles(element, styles) {
2713 Object.keys(styles).forEach(function (prop) {
2714 var unit = '';
2715 // add unit if the value is numeric and is one of the following
2716 if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
2717 unit = 'px';
2718 }
2719 element.style[prop] = styles[prop] + unit;
2720 });
2721 }
2722
2723 /**
2724 * Set the attributes to the given popper
2725 * @method
2726 * @memberof Popper.Utils
2727 * @argument {Element} element - Element to apply the attributes to
2728 * @argument {Object} styles
2729 * Object with a list of properties and values which will be applied to the element
2730 */
2731 function setAttributes(element, attributes) {
2732 Object.keys(attributes).forEach(function (prop) {
2733 var value = attributes[prop];
2734 if (value !== false) {
2735 element.setAttribute(prop, attributes[prop]);
2736 } else {
2737 element.removeAttribute(prop);
2738 }
2739 });
2740 }
2741
2742 /**
2743 * @function
2744 * @memberof Modifiers
2745 * @argument {Object} data - The data object generated by `update` method
2746 * @argument {Object} data.styles - List of style properties - values to apply to popper element
2747 * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element
2748 * @argument {Object} options - Modifiers configuration and options
2749 * @returns {Object} The same data object
2750 */
2751 function applyStyle(data) {
2752 // any property present in `data.styles` will be applied to the popper,
2753 // in this way we can make the 3rd party modifiers add custom styles to it
2754 // Be aware, modifiers could override the properties defined in the previous
2755 // lines of this modifier!
2756 setStyles(data.instance.popper, data.styles);
2757
2758 // any property present in `data.attributes` will be applied to the popper,
2759 // they will be set as HTML attributes of the element
2760 setAttributes(data.instance.popper, data.attributes);
2761
2762 // if arrowElement is defined and arrowStyles has some properties
2763 if (data.arrowElement && Object.keys(data.arrowStyles).length) {
2764 setStyles(data.arrowElement, data.arrowStyles);
2765 }
2766
2767 return data;
2768 }
2769
2770 /**
2771 * Set the x-placement attribute before everything else because it could be used
2772 * to add margins to the popper margins needs to be calculated to get the
2773 * correct popper offsets.
2774 * @method
2775 * @memberof Popper.modifiers
2776 * @param {HTMLElement} reference - The reference element used to position the popper
2777 * @param {HTMLElement} popper - The HTML element used as popper
2778 * @param {Object} options - Popper.js options
2779 */
2780 function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
2781 // compute reference element offsets
2782 var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);
2783
2784 // compute auto placement, store placement inside the data object,
2785 // modifiers will be able to edit `placement` if needed
2786 // and refer to originalPlacement to know the original value
2787 var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
2788
2789 popper.setAttribute('x-placement', placement);
2790
2791 // Apply `position` to popper before anything else because
2792 // without the position applied we can't guarantee correct computations
2793 setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });
2794
2795 return options;
2796 }
2797
2798 /**
2799 * @function
2800 * @memberof Popper.Utils
2801 * @argument {Object} data - The data object generated by `update` method
2802 * @argument {Boolean} shouldRound - If the offsets should be rounded at all
2803 * @returns {Object} The popper's position offsets rounded
2804 *
2805 * The tale of pixel-perfect positioning. It's still not 100% perfect, but as
2806 * good as it can be within reason.
2807 * Discussion here: https://github.com/FezVrasta/popper.js/pull/715
2808 *
2809 * Low DPI screens cause a popper to be blurry if not using full pixels (Safari
2810 * as well on High DPI screens).
2811 *
2812 * Firefox prefers no rounding for positioning and does not have blurriness on
2813 * high DPI screens.
2814 *
2815 * Only horizontal placement and left/right values need to be considered.
2816 */
2817 function getRoundedOffsets(data, shouldRound) {
2818 var _data$offsets = data.offsets,
2819 popper = _data$offsets.popper,
2820 reference = _data$offsets.reference;
2821 var round = Math.round,
2822 floor = Math.floor;
2823
2824 var noRound = function noRound(v) {
2825 return v;
2826 };
2827
2828 var referenceWidth = round(reference.width);
2829 var popperWidth = round(popper.width);
2830
2831 var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;
2832 var isVariation = data.placement.indexOf('-') !== -1;
2833 var sameWidthParity = referenceWidth % 2 === popperWidth % 2;
2834 var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;
2835
2836 var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;
2837 var verticalToInteger = !shouldRound ? noRound : round;
2838
2839 return {
2840 left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),
2841 top: verticalToInteger(popper.top),
2842 bottom: verticalToInteger(popper.bottom),
2843 right: horizontalToInteger(popper.right)
2844 };
2845 }
2846
2847 var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);
2848
2849 /**
2850 * @function
2851 * @memberof Modifiers
2852 * @argument {Object} data - The data object generated by `update` method
2853 * @argument {Object} options - Modifiers configuration and options
2854 * @returns {Object} The data object, properly modified
2855 */
2856 function computeStyle(data, options) {
2857 var x = options.x,
2858 y = options.y;
2859 var popper = data.offsets.popper;
2860
2861 // Remove this legacy support in Popper.js v2
2862
2863 var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
2864 return modifier.name === 'applyStyle';
2865 }).gpuAcceleration;
2866 if (legacyGpuAccelerationOption !== undefined) {
2867 console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
2868 }
2869 var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
2870
2871 var offsetParent = getOffsetParent(data.instance.popper);
2872 var offsetParentRect = getBoundingClientRect(offsetParent);
2873
2874 // Styles
2875 var styles = {
2876 position: popper.position
2877 };
2878
2879 var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);
2880
2881 var sideA = x === 'bottom' ? 'top' : 'bottom';
2882 var sideB = y === 'right' ? 'left' : 'right';
2883
2884 // if gpuAcceleration is set to `true` and transform is supported,
2885 // we use `translate3d` to apply the position to the popper we
2886 // automatically use the supported prefixed version if needed
2887 var prefixedProperty = getSupportedPropertyName('transform');
2888
2889 // now, let's make a step back and look at this code closely (wtf?)
2890 // If the content of the popper grows once it's been positioned, it
2891 // may happen that the popper gets misplaced because of the new content
2892 // overflowing its reference element
2893 // To avoid this problem, we provide two options (x and y), which allow
2894 // the consumer to define the offset origin.
2895 // If we position a popper on top of a reference element, we can set
2896 // `x` to `top` to make the popper grow towards its top instead of
2897 // its bottom.
2898 var left = void 0,
2899 top = void 0;
2900 if (sideA === 'bottom') {
2901 // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)
2902 // and not the bottom of the html element
2903 if (offsetParent.nodeName === 'HTML') {
2904 top = -offsetParent.clientHeight + offsets.bottom;
2905 } else {
2906 top = -offsetParentRect.height + offsets.bottom;
2907 }
2908 } else {
2909 top = offsets.top;
2910 }
2911 if (sideB === 'right') {
2912 if (offsetParent.nodeName === 'HTML') {
2913 left = -offsetParent.clientWidth + offsets.right;
2914 } else {
2915 left = -offsetParentRect.width + offsets.right;
2916 }
2917 } else {
2918 left = offsets.left;
2919 }
2920 if (gpuAcceleration && prefixedProperty) {
2921 styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';
2922 styles[sideA] = 0;
2923 styles[sideB] = 0;
2924 styles.willChange = 'transform';
2925 } else {
2926 // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
2927 var invertTop = sideA === 'bottom' ? -1 : 1;
2928 var invertLeft = sideB === 'right' ? -1 : 1;
2929 styles[sideA] = top * invertTop;
2930 styles[sideB] = left * invertLeft;
2931 styles.willChange = sideA + ', ' + sideB;
2932 }
2933
2934 // Attributes
2935 var attributes = {
2936 'x-placement': data.placement
2937 };
2938
2939 // Update `data` attributes, styles and arrowStyles
2940 data.attributes = _extends({}, attributes, data.attributes);
2941 data.styles = _extends({}, styles, data.styles);
2942 data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);
2943
2944 return data;
2945 }
2946
2947 /**
2948 * Helper used to know if the given modifier depends from another one.<br />
2949 * It checks if the needed modifier is listed and enabled.
2950 * @method
2951 * @memberof Popper.Utils
2952 * @param {Array} modifiers - list of modifiers
2953 * @param {String} requestingName - name of requesting modifier
2954 * @param {String} requestedName - name of requested modifier
2955 * @returns {Boolean}
2956 */
2957 function isModifierRequired(modifiers, requestingName, requestedName) {
2958 var requesting = find(modifiers, function (_ref) {
2959 var name = _ref.name;
2960 return name === requestingName;
2961 });
2962
2963 var isRequired = !!requesting && modifiers.some(function (modifier) {
2964 return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
2965 });
2966
2967 if (!isRequired) {
2968 var _requesting = '`' + requestingName + '`';
2969 var requested = '`' + requestedName + '`';
2970 console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
2971 }
2972 return isRequired;
2973 }
2974
2975 /**
2976 * @function
2977 * @memberof Modifiers
2978 * @argument {Object} data - The data object generated by update method
2979 * @argument {Object} options - Modifiers configuration and options
2980 * @returns {Object} The data object, properly modified
2981 */
2982 function arrow(data, options) {
2983 var _data$offsets$arrow;
2984
2985 // arrow depends on keepTogether in order to work
2986 if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
2987 return data;
2988 }
2989
2990 var arrowElement = options.element;
2991
2992 // if arrowElement is a string, suppose it's a CSS selector
2993 if (typeof arrowElement === 'string') {
2994 arrowElement = data.instance.popper.querySelector(arrowElement);
2995
2996 // if arrowElement is not found, don't run the modifier
2997 if (!arrowElement) {
2998 return data;
2999 }
3000 } else {
3001 // if the arrowElement isn't a query selector we must check that the
3002 // provided DOM node is child of its popper node
3003 if (!data.instance.popper.contains(arrowElement)) {
3004 console.warn('WARNING: `arrow.element` must be child of its popper element!');
3005 return data;
3006 }
3007 }
3008
3009 var placement = data.placement.split('-')[0];
3010 var _data$offsets = data.offsets,
3011 popper = _data$offsets.popper,
3012 reference = _data$offsets.reference;
3013
3014 var isVertical = ['left', 'right'].indexOf(placement) !== -1;
3015
3016 var len = isVertical ? 'height' : 'width';
3017 var sideCapitalized = isVertical ? 'Top' : 'Left';
3018 var side = sideCapitalized.toLowerCase();
3019 var altSide = isVertical ? 'left' : 'top';
3020 var opSide = isVertical ? 'bottom' : 'right';
3021 var arrowElementSize = getOuterSizes(arrowElement)[len];
3022
3023 //
3024 // extends keepTogether behavior making sure the popper and its
3025 // reference have enough pixels in conjunction
3026 //
3027
3028 // top/left side
3029 if (reference[opSide] - arrowElementSize < popper[side]) {
3030 data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
3031 }
3032 // bottom/right side
3033 if (reference[side] + arrowElementSize > popper[opSide]) {
3034 data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
3035 }
3036 data.offsets.popper = getClientRect(data.offsets.popper);
3037
3038 // compute center of the popper
3039 var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
3040
3041 // Compute the sideValue using the updated popper offsets
3042 // take popper margin in account because we don't have this info available
3043 var css = getStyleComputedProperty(data.instance.popper);
3044 var popperMarginSide = parseFloat(css['margin' + sideCapitalized], 10);
3045 var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width'], 10);
3046 var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
3047
3048 // prevent arrowElement from being placed not contiguously to its popper
3049 sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
3050
3051 data.arrowElement = arrowElement;
3052 data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);
3053
3054 return data;
3055 }
3056
3057 /**
3058 * Get the opposite placement variation of the given one
3059 * @method
3060 * @memberof Popper.Utils
3061 * @argument {String} placement variation
3062 * @returns {String} flipped placement variation
3063 */
3064 function getOppositeVariation(variation) {
3065 if (variation === 'end') {
3066 return 'start';
3067 } else if (variation === 'start') {
3068 return 'end';
3069 }
3070 return variation;
3071 }
3072
3073 /**
3074 * List of accepted placements to use as values of the `placement` option.<br />
3075 * Valid placements are:
3076 * - `auto`
3077 * - `top`
3078 * - `right`
3079 * - `bottom`
3080 * - `left`
3081 *
3082 * Each placement can have a variation from this list:
3083 * - `-start`
3084 * - `-end`
3085 *
3086 * Variations are interpreted easily if you think of them as the left to right
3087 * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`
3088 * is right.<br />
3089 * Vertically (`left` and `right`), `start` is top and `end` is bottom.
3090 *
3091 * Some valid examples are:
3092 * - `top-end` (on top of reference, right aligned)
3093 * - `right-start` (on right of reference, top aligned)
3094 * - `bottom` (on bottom, centered)
3095 * - `auto-end` (on the side with more space available, alignment depends by placement)
3096 *
3097 * @static
3098 * @type {Array}
3099 * @enum {String}
3100 * @readonly
3101 * @method placements
3102 * @memberof Popper
3103 */
3104 var placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];
3105
3106 // Get rid of `auto` `auto-start` and `auto-end`
3107 var validPlacements = placements.slice(3);
3108
3109 /**
3110 * Given an initial placement, returns all the subsequent placements
3111 * clockwise (or counter-clockwise).
3112 *
3113 * @method
3114 * @memberof Popper.Utils
3115 * @argument {String} placement - A valid placement (it accepts variations)
3116 * @argument {Boolean} counter - Set to true to walk the placements counterclockwise
3117 * @returns {Array} placements including their variations
3118 */
3119 function clockwise(placement) {
3120 var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
3121
3122 var index = validPlacements.indexOf(placement);
3123 var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
3124 return counter ? arr.reverse() : arr;
3125 }
3126
3127 var BEHAVIORS = {
3128 FLIP: 'flip',
3129 CLOCKWISE: 'clockwise',
3130 COUNTERCLOCKWISE: 'counterclockwise'
3131 };
3132
3133 /**
3134 * @function
3135 * @memberof Modifiers
3136 * @argument {Object} data - The data object generated by update method
3137 * @argument {Object} options - Modifiers configuration and options
3138 * @returns {Object} The data object, properly modified
3139 */
3140 function flip(data, options) {
3141 // if `inner` modifier is enabled, we can't use the `flip` modifier
3142 if (isModifierEnabled(data.instance.modifiers, 'inner')) {
3143 return data;
3144 }
3145
3146 if (data.flipped && data.placement === data.originalPlacement) {
3147 // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides
3148 return data;
3149 }
3150
3151 var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);
3152
3153 var placement = data.placement.split('-')[0];
3154 var placementOpposite = getOppositePlacement(placement);
3155 var variation = data.placement.split('-')[1] || '';
3156
3157 var flipOrder = [];
3158
3159 switch (options.behavior) {
3160 case BEHAVIORS.FLIP:
3161 flipOrder = [placement, placementOpposite];
3162 break;
3163 case BEHAVIORS.CLOCKWISE:
3164 flipOrder = clockwise(placement);
3165 break;
3166 case BEHAVIORS.COUNTERCLOCKWISE:
3167 flipOrder = clockwise(placement, true);
3168 break;
3169 default:
3170 flipOrder = options.behavior;
3171 }
3172
3173 flipOrder.forEach(function (step, index) {
3174 if (placement !== step || flipOrder.length === index + 1) {
3175 return data;
3176 }
3177
3178 placement = data.placement.split('-')[0];
3179 placementOpposite = getOppositePlacement(placement);
3180
3181 var popperOffsets = data.offsets.popper;
3182 var refOffsets = data.offsets.reference;
3183
3184 // using floor because the reference offsets may contain decimals we are not going to consider here
3185 var floor = Math.floor;
3186 var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom);
3187
3188 var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
3189 var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
3190 var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
3191 var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
3192
3193 var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;
3194
3195 // flip the variation if required
3196 var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
3197
3198 // flips variation if reference element overflows boundaries
3199 var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);
3200
3201 // flips variation if popper content overflows boundaries
3202 var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop);
3203
3204 var flippedVariation = flippedVariationByRef || flippedVariationByContent;
3205
3206 if (overlapsRef || overflowsBoundaries || flippedVariation) {
3207 // this boolean to detect any flip loop
3208 data.flipped = true;
3209
3210 if (overlapsRef || overflowsBoundaries) {
3211 placement = flipOrder[index + 1];
3212 }
3213
3214 if (flippedVariation) {
3215 variation = getOppositeVariation(variation);
3216 }
3217
3218 data.placement = placement + (variation ? '-' + variation : '');
3219
3220 // this object contains `position`, we want to preserve it along with
3221 // any additional property we may add in the future
3222 data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
3223
3224 data = runModifiers(data.instance.modifiers, data, 'flip');
3225 }
3226 });
3227 return data;
3228 }
3229
3230 /**
3231 * @function
3232 * @memberof Modifiers
3233 * @argument {Object} data - The data object generated by update method
3234 * @argument {Object} options - Modifiers configuration and options
3235 * @returns {Object} The data object, properly modified
3236 */
3237 function keepTogether(data) {
3238 var _data$offsets = data.offsets,
3239 popper = _data$offsets.popper,
3240 reference = _data$offsets.reference;
3241
3242 var placement = data.placement.split('-')[0];
3243 var floor = Math.floor;
3244 var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
3245 var side = isVertical ? 'right' : 'bottom';
3246 var opSide = isVertical ? 'left' : 'top';
3247 var measurement = isVertical ? 'width' : 'height';
3248
3249 if (popper[side] < floor(reference[opSide])) {
3250 data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
3251 }
3252 if (popper[opSide] > floor(reference[side])) {
3253 data.offsets.popper[opSide] = floor(reference[side]);
3254 }
3255
3256 return data;
3257 }
3258
3259 /**
3260 * Converts a string containing value + unit into a px value number
3261 * @function
3262 * @memberof {modifiers~offset}
3263 * @private
3264 * @argument {String} str - Value + unit string
3265 * @argument {String} measurement - `height` or `width`
3266 * @argument {Object} popperOffsets
3267 * @argument {Object} referenceOffsets
3268 * @returns {Number|String}
3269 * Value in pixels, or original string if no values were extracted
3270 */
3271 function toValue(str, measurement, popperOffsets, referenceOffsets) {
3272 // separate value from unit
3273 var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
3274 var value = +split[1];
3275 var unit = split[2];
3276
3277 // If it's not a number it's an operator, I guess
3278 if (!value) {
3279 return str;
3280 }
3281
3282 if (unit.indexOf('%') === 0) {
3283 var element = void 0;
3284 switch (unit) {
3285 case '%p':
3286 element = popperOffsets;
3287 break;
3288 case '%':
3289 case '%r':
3290 default:
3291 element = referenceOffsets;
3292 }
3293
3294 var rect = getClientRect(element);
3295 return rect[measurement] / 100 * value;
3296 } else if (unit === 'vh' || unit === 'vw') {
3297 // if is a vh or vw, we calculate the size based on the viewport
3298 var size = void 0;
3299 if (unit === 'vh') {
3300 size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
3301 } else {
3302 size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
3303 }
3304 return size / 100 * value;
3305 } else {
3306 // if is an explicit pixel unit, we get rid of the unit and keep the value
3307 // if is an implicit unit, it's px, and we return just the value
3308 return value;
3309 }
3310 }
3311
3312 /**
3313 * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.
3314 * @function
3315 * @memberof {modifiers~offset}
3316 * @private
3317 * @argument {String} offset
3318 * @argument {Object} popperOffsets
3319 * @argument {Object} referenceOffsets
3320 * @argument {String} basePlacement
3321 * @returns {Array} a two cells array with x and y offsets in numbers
3322 */
3323 function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {
3324 var offsets = [0, 0];
3325
3326 // Use height if placement is left or right and index is 0 otherwise use width
3327 // in this way the first offset will use an axis and the second one
3328 // will use the other one
3329 var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
3330
3331 // Split the offset string to obtain a list of values and operands
3332 // The regex addresses values with the plus or minus sign in front (+10, -20, etc)
3333 var fragments = offset.split(/(\+|\-)/).map(function (frag) {
3334 return frag.trim();
3335 });
3336
3337 // Detect if the offset string contains a pair of values or a single one
3338 // they could be separated by comma or space
3339 var divider = fragments.indexOf(find(fragments, function (frag) {
3340 return frag.search(/,|\s/) !== -1;
3341 }));
3342
3343 if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
3344 console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
3345 }
3346
3347 // If divider is found, we divide the list of values and operands to divide
3348 // them by ofset X and Y.
3349 var splitRegex = /\s*,\s*|\s+/;
3350 var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];
3351
3352 // Convert the values with units to absolute pixels to allow our computations
3353 ops = ops.map(function (op, index) {
3354 // Most of the units rely on the orientation of the popper
3355 var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
3356 var mergeWithPrevious = false;
3357 return op
3358 // This aggregates any `+` or `-` sign that aren't considered operators
3359 // e.g.: 10 + +5 => [10, +, +5]
3360 .reduce(function (a, b) {
3361 if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {
3362 a[a.length - 1] = b;
3363 mergeWithPrevious = true;
3364 return a;
3365 } else if (mergeWithPrevious) {
3366 a[a.length - 1] += b;
3367 mergeWithPrevious = false;
3368 return a;
3369 } else {
3370 return a.concat(b);
3371 }
3372 }, [])
3373 // Here we convert the string values into number values (in px)
3374 .map(function (str) {
3375 return toValue(str, measurement, popperOffsets, referenceOffsets);
3376 });
3377 });
3378
3379 // Loop trough the offsets arrays and execute the operations
3380 ops.forEach(function (op, index) {
3381 op.forEach(function (frag, index2) {
3382 if (isNumeric(frag)) {
3383 offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
3384 }
3385 });
3386 });
3387 return offsets;
3388 }
3389
3390 /**
3391 * @function
3392 * @memberof Modifiers
3393 * @argument {Object} data - The data object generated by update method
3394 * @argument {Object} options - Modifiers configuration and options
3395 * @argument {Number|String} options.offset=0
3396 * The offset value as described in the modifier description
3397 * @returns {Object} The data object, properly modified
3398 */
3399 function offset(data, _ref) {
3400 var offset = _ref.offset;
3401 var placement = data.placement,
3402 _data$offsets = data.offsets,
3403 popper = _data$offsets.popper,
3404 reference = _data$offsets.reference;
3405
3406 var basePlacement = placement.split('-')[0];
3407
3408 var offsets = void 0;
3409 if (isNumeric(+offset)) {
3410 offsets = [+offset, 0];
3411 } else {
3412 offsets = parseOffset(offset, popper, reference, basePlacement);
3413 }
3414
3415 if (basePlacement === 'left') {
3416 popper.top += offsets[0];
3417 popper.left -= offsets[1];
3418 } else if (basePlacement === 'right') {
3419 popper.top += offsets[0];
3420 popper.left += offsets[1];
3421 } else if (basePlacement === 'top') {
3422 popper.left += offsets[0];
3423 popper.top -= offsets[1];
3424 } else if (basePlacement === 'bottom') {
3425 popper.left += offsets[0];
3426 popper.top += offsets[1];
3427 }
3428
3429 data.popper = popper;
3430 return data;
3431 }
3432
3433 /**
3434 * @function
3435 * @memberof Modifiers
3436 * @argument {Object} data - The data object generated by `update` method
3437 * @argument {Object} options - Modifiers configuration and options
3438 * @returns {Object} The data object, properly modified
3439 */
3440 function preventOverflow(data, options) {
3441 var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
3442
3443 // If offsetParent is the reference element, we really want to
3444 // go one step up and use the next offsetParent as reference to
3445 // avoid to make this modifier completely useless and look like broken
3446 if (data.instance.reference === boundariesElement) {
3447 boundariesElement = getOffsetParent(boundariesElement);
3448 }
3449
3450 // NOTE: DOM access here
3451 // resets the popper's position so that the document size can be calculated excluding
3452 // the size of the popper element itself
3453 var transformProp = getSupportedPropertyName('transform');
3454 var popperStyles = data.instance.popper.style; // assignment to help minification
3455 var top = popperStyles.top,
3456 left = popperStyles.left,
3457 transform = popperStyles[transformProp];
3458
3459 popperStyles.top = '';
3460 popperStyles.left = '';
3461 popperStyles[transformProp] = '';
3462
3463 var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);
3464
3465 // NOTE: DOM access here
3466 // restores the original style properties after the offsets have been computed
3467 popperStyles.top = top;
3468 popperStyles.left = left;
3469 popperStyles[transformProp] = transform;
3470
3471 options.boundaries = boundaries;
3472
3473 var order = options.priority;
3474 var popper = data.offsets.popper;
3475
3476 var check = {
3477 primary: function primary(placement) {
3478 var value = popper[placement];
3479 if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
3480 value = Math.max(popper[placement], boundaries[placement]);
3481 }
3482 return defineProperty({}, placement, value);
3483 },
3484 secondary: function secondary(placement) {
3485 var mainSide = placement === 'right' ? 'left' : 'top';
3486 var value = popper[mainSide];
3487 if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
3488 value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));
3489 }
3490 return defineProperty({}, mainSide, value);
3491 }
3492 };
3493
3494 order.forEach(function (placement) {
3495 var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';
3496 popper = _extends({}, popper, check[side](placement));
3497 });
3498
3499 data.offsets.popper = popper;
3500
3501 return data;
3502 }
3503
3504 /**
3505 * @function
3506 * @memberof Modifiers
3507 * @argument {Object} data - The data object generated by `update` method
3508 * @argument {Object} options - Modifiers configuration and options
3509 * @returns {Object} The data object, properly modified
3510 */
3511 function shift(data) {
3512 var placement = data.placement;
3513 var basePlacement = placement.split('-')[0];
3514 var shiftvariation = placement.split('-')[1];
3515
3516 // if shift shiftvariation is specified, run the modifier
3517 if (shiftvariation) {
3518 var _data$offsets = data.offsets,
3519 reference = _data$offsets.reference,
3520 popper = _data$offsets.popper;
3521
3522 var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
3523 var side = isVertical ? 'left' : 'top';
3524 var measurement = isVertical ? 'width' : 'height';
3525
3526 var shiftOffsets = {
3527 start: defineProperty({}, side, reference[side]),
3528 end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
3529 };
3530
3531 data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);
3532 }
3533
3534 return data;
3535 }
3536
3537 /**
3538 * @function
3539 * @memberof Modifiers
3540 * @argument {Object} data - The data object generated by update method
3541 * @argument {Object} options - Modifiers configuration and options
3542 * @returns {Object} The data object, properly modified
3543 */
3544 function hide(data) {
3545 if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {
3546 return data;
3547 }
3548
3549 var refRect = data.offsets.reference;
3550 var bound = find(data.instance.modifiers, function (modifier) {
3551 return modifier.name === 'preventOverflow';
3552 }).boundaries;
3553
3554 if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
3555 // Avoid unnecessary DOM access if visibility hasn't changed
3556 if (data.hide === true) {
3557 return data;
3558 }
3559
3560 data.hide = true;
3561 data.attributes['x-out-of-boundaries'] = '';
3562 } else {
3563 // Avoid unnecessary DOM access if visibility hasn't changed
3564 if (data.hide === false) {
3565 return data;
3566 }
3567
3568 data.hide = false;
3569 data.attributes['x-out-of-boundaries'] = false;
3570 }
3571
3572 return data;
3573 }
3574
3575 /**
3576 * @function
3577 * @memberof Modifiers
3578 * @argument {Object} data - The data object generated by `update` method
3579 * @argument {Object} options - Modifiers configuration and options
3580 * @returns {Object} The data object, properly modified
3581 */
3582 function inner(data) {
3583 var placement = data.placement;
3584 var basePlacement = placement.split('-')[0];
3585 var _data$offsets = data.offsets,
3586 popper = _data$offsets.popper,
3587 reference = _data$offsets.reference;
3588
3589 var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
3590
3591 var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
3592
3593 popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
3594
3595 data.placement = getOppositePlacement(placement);
3596 data.offsets.popper = getClientRect(popper);
3597
3598 return data;
3599 }
3600
3601 /**
3602 * Modifier function, each modifier can have a function of this type assigned
3603 * to its `fn` property.<br />
3604 * These functions will be called on each update, this means that you must
3605 * make sure they are performant enough to avoid performance bottlenecks.
3606 *
3607 * @function ModifierFn
3608 * @argument {dataObject} data - The data object generated by `update` method
3609 * @argument {Object} options - Modifiers configuration and options
3610 * @returns {dataObject} The data object, properly modified
3611 */
3612
3613 /**
3614 * Modifiers are plugins used to alter the behavior of your poppers.<br />
3615 * Popper.js uses a set of 9 modifiers to provide all the basic functionalities
3616 * needed by the library.
3617 *
3618 * Usually you don't want to override the `order`, `fn` and `onLoad` props.
3619 * All the other properties are configurations that could be tweaked.
3620 * @namespace modifiers
3621 */
3622 var modifiers = {
3623 /**
3624 * Modifier used to shift the popper on the start or end of its reference
3625 * element.<br />
3626 * It will read the variation of the `placement` property.<br />
3627 * It can be one either `-end` or `-start`.
3628 * @memberof modifiers
3629 * @inner
3630 */
3631 shift: {
3632 /** @prop {number} order=100 - Index used to define the order of execution */
3633 order: 100,
3634 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
3635 enabled: true,
3636 /** @prop {ModifierFn} */
3637 fn: shift
3638 },
3639
3640 /**
3641 * The `offset` modifier can shift your popper on both its axis.
3642 *
3643 * It accepts the following units:
3644 * - `px` or unit-less, interpreted as pixels
3645 * - `%` or `%r`, percentage relative to the length of the reference element
3646 * - `%p`, percentage relative to the length of the popper element
3647 * - `vw`, CSS viewport width unit
3648 * - `vh`, CSS viewport height unit
3649 *
3650 * For length is intended the main axis relative to the placement of the popper.<br />
3651 * This means that if the placement is `top` or `bottom`, the length will be the
3652 * `width`. In case of `left` or `right`, it will be the `height`.
3653 *
3654 * You can provide a single value (as `Number` or `String`), or a pair of values
3655 * as `String` divided by a comma or one (or more) white spaces.<br />
3656 * The latter is a deprecated method because it leads to confusion and will be
3657 * removed in v2.<br />
3658 * Additionally, it accepts additions and subtractions between different units.
3659 * Note that multiplications and divisions aren't supported.
3660 *
3661 * Valid examples are:
3662 * ```
3663 * 10
3664 * '10%'
3665 * '10, 10'
3666 * '10%, 10'
3667 * '10 + 10%'
3668 * '10 - 5vh + 3%'
3669 * '-10px + 5vh, 5px - 6%'
3670 * ```
3671 * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap
3672 * > with their reference element, unfortunately, you will have to disable the `flip` modifier.
3673 * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).
3674 *
3675 * @memberof modifiers
3676 * @inner
3677 */
3678 offset: {
3679 /** @prop {number} order=200 - Index used to define the order of execution */
3680 order: 200,
3681 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
3682 enabled: true,
3683 /** @prop {ModifierFn} */
3684 fn: offset,
3685 /** @prop {Number|String} offset=0
3686 * The offset value as described in the modifier description
3687 */
3688 offset: 0
3689 },
3690
3691 /**
3692 * Modifier used to prevent the popper from being positioned outside the boundary.
3693 *
3694 * A scenario exists where the reference itself is not within the boundaries.<br />
3695 * We can say it has "escaped the boundaries" — or just "escaped".<br />
3696 * In this case we need to decide whether the popper should either:
3697 *
3698 * - detach from the reference and remain "trapped" in the boundaries, or
3699 * - if it should ignore the boundary and "escape with its reference"
3700 *
3701 * When `escapeWithReference` is set to`true` and reference is completely
3702 * outside its boundaries, the popper will overflow (or completely leave)
3703 * the boundaries in order to remain attached to the edge of the reference.
3704 *
3705 * @memberof modifiers
3706 * @inner
3707 */
3708 preventOverflow: {
3709 /** @prop {number} order=300 - Index used to define the order of execution */
3710 order: 300,
3711 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
3712 enabled: true,
3713 /** @prop {ModifierFn} */
3714 fn: preventOverflow,
3715 /**
3716 * @prop {Array} [priority=['left','right','top','bottom']]
3717 * Popper will try to prevent overflow following these priorities by default,
3718 * then, it could overflow on the left and on top of the `boundariesElement`
3719 */
3720 priority: ['left', 'right', 'top', 'bottom'],
3721 /**
3722 * @prop {number} padding=5
3723 * Amount of pixel used to define a minimum distance between the boundaries
3724 * and the popper. This makes sure the popper always has a little padding
3725 * between the edges of its container
3726 */
3727 padding: 5,
3728 /**
3729 * @prop {String|HTMLElement} boundariesElement='scrollParent'
3730 * Boundaries used by the modifier. Can be `scrollParent`, `window`,
3731 * `viewport` or any DOM element.
3732 */
3733 boundariesElement: 'scrollParent'
3734 },
3735
3736 /**
3737 * Modifier used to make sure the reference and its popper stay near each other
3738 * without leaving any gap between the two. Especially useful when the arrow is
3739 * enabled and you want to ensure that it points to its reference element.
3740 * It cares only about the first axis. You can still have poppers with margin
3741 * between the popper and its reference element.
3742 * @memberof modifiers
3743 * @inner
3744 */
3745 keepTogether: {
3746 /** @prop {number} order=400 - Index used to define the order of execution */
3747 order: 400,
3748 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
3749 enabled: true,
3750 /** @prop {ModifierFn} */
3751 fn: keepTogether
3752 },
3753
3754 /**
3755 * This modifier is used to move the `arrowElement` of the popper to make
3756 * sure it is positioned between the reference element and its popper element.
3757 * It will read the outer size of the `arrowElement` node to detect how many
3758 * pixels of conjunction are needed.
3759 *
3760 * It has no effect if no `arrowElement` is provided.
3761 * @memberof modifiers
3762 * @inner
3763 */
3764 arrow: {
3765 /** @prop {number} order=500 - Index used to define the order of execution */
3766 order: 500,
3767 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
3768 enabled: true,
3769 /** @prop {ModifierFn} */
3770 fn: arrow,
3771 /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */
3772 element: '[x-arrow]'
3773 },
3774
3775 /**
3776 * Modifier used to flip the popper's placement when it starts to overlap its
3777 * reference element.
3778 *
3779 * Requires the `preventOverflow` modifier before it in order to work.
3780 *
3781 * **NOTE:** this modifier will interrupt the current update cycle and will
3782 * restart it if it detects the need to flip the placement.
3783 * @memberof modifiers
3784 * @inner
3785 */
3786 flip: {
3787 /** @prop {number} order=600 - Index used to define the order of execution */
3788 order: 600,
3789 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
3790 enabled: true,
3791 /** @prop {ModifierFn} */
3792 fn: flip,
3793 /**
3794 * @prop {String|Array} behavior='flip'
3795 * The behavior used to change the popper's placement. It can be one of
3796 * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid
3797 * placements (with optional variations)
3798 */
3799 behavior: 'flip',
3800 /**
3801 * @prop {number} padding=5
3802 * The popper will flip if it hits the edges of the `boundariesElement`
3803 */
3804 padding: 5,
3805 /**
3806 * @prop {String|HTMLElement} boundariesElement='viewport'
3807 * The element which will define the boundaries of the popper position.
3808 * The popper will never be placed outside of the defined boundaries
3809 * (except if `keepTogether` is enabled)
3810 */
3811 boundariesElement: 'viewport',
3812 /**
3813 * @prop {Boolean} flipVariations=false
3814 * The popper will switch placement variation between `-start` and `-end` when
3815 * the reference element overlaps its boundaries.
3816 *
3817 * The original placement should have a set variation.
3818 */
3819 flipVariations: false,
3820 /**
3821 * @prop {Boolean} flipVariationsByContent=false
3822 * The popper will switch placement variation between `-start` and `-end` when
3823 * the popper element overlaps its reference boundaries.
3824 *
3825 * The original placement should have a set variation.
3826 */
3827 flipVariationsByContent: false
3828 },
3829
3830 /**
3831 * Modifier used to make the popper flow toward the inner of the reference element.
3832 * By default, when this modifier is disabled, the popper will be placed outside
3833 * the reference element.
3834 * @memberof modifiers
3835 * @inner
3836 */
3837 inner: {
3838 /** @prop {number} order=700 - Index used to define the order of execution */
3839 order: 700,
3840 /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */
3841 enabled: false,
3842 /** @prop {ModifierFn} */
3843 fn: inner
3844 },
3845
3846 /**
3847 * Modifier used to hide the popper when its reference element is outside of the
3848 * popper boundaries. It will set a `x-out-of-boundaries` attribute which can
3849 * be used to hide with a CSS selector the popper when its reference is
3850 * out of boundaries.
3851 *
3852 * Requires the `preventOverflow` modifier before it in order to work.
3853 * @memberof modifiers
3854 * @inner
3855 */
3856 hide: {
3857 /** @prop {number} order=800 - Index used to define the order of execution */
3858 order: 800,
3859 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
3860 enabled: true,
3861 /** @prop {ModifierFn} */
3862 fn: hide
3863 },
3864
3865 /**
3866 * Computes the style that will be applied to the popper element to gets
3867 * properly positioned.
3868 *
3869 * Note that this modifier will not touch the DOM, it just prepares the styles
3870 * so that `applyStyle` modifier can apply it. This separation is useful
3871 * in case you need to replace `applyStyle` with a custom implementation.
3872 *
3873 * This modifier has `850` as `order` value to maintain backward compatibility
3874 * with previous versions of Popper.js. Expect the modifiers ordering method
3875 * to change in future major versions of the library.
3876 *
3877 * @memberof modifiers
3878 * @inner
3879 */
3880 computeStyle: {
3881 /** @prop {number} order=850 - Index used to define the order of execution */
3882 order: 850,
3883 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
3884 enabled: true,
3885 /** @prop {ModifierFn} */
3886 fn: computeStyle,
3887 /**
3888 * @prop {Boolean} gpuAcceleration=true
3889 * If true, it uses the CSS 3D transformation to position the popper.
3890 * Otherwise, it will use the `top` and `left` properties
3891 */
3892 gpuAcceleration: true,
3893 /**
3894 * @prop {string} [x='bottom']
3895 * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.
3896 * Change this if your popper should grow in a direction different from `bottom`
3897 */
3898 x: 'bottom',
3899 /**
3900 * @prop {string} [x='left']
3901 * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.
3902 * Change this if your popper should grow in a direction different from `right`
3903 */
3904 y: 'right'
3905 },
3906
3907 /**
3908 * Applies the computed styles to the popper element.
3909 *
3910 * All the DOM manipulations are limited to this modifier. This is useful in case
3911 * you want to integrate Popper.js inside a framework or view library and you
3912 * want to delegate all the DOM manipulations to it.
3913 *
3914 * Note that if you disable this modifier, you must make sure the popper element
3915 * has its position set to `absolute` before Popper.js can do its work!
3916 *
3917 * Just disable this modifier and define your own to achieve the desired effect.
3918 *
3919 * @memberof modifiers
3920 * @inner
3921 */
3922 applyStyle: {
3923 /** @prop {number} order=900 - Index used to define the order of execution */
3924 order: 900,
3925 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
3926 enabled: true,
3927 /** @prop {ModifierFn} */
3928 fn: applyStyle,
3929 /** @prop {Function} */
3930 onLoad: applyStyleOnLoad,
3931 /**
3932 * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier
3933 * @prop {Boolean} gpuAcceleration=true
3934 * If true, it uses the CSS 3D transformation to position the popper.
3935 * Otherwise, it will use the `top` and `left` properties
3936 */
3937 gpuAcceleration: undefined
3938 }
3939 };
3940
3941 /**
3942 * The `dataObject` is an object containing all the information used by Popper.js.
3943 * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.
3944 * @name dataObject
3945 * @property {Object} data.instance The Popper.js instance
3946 * @property {String} data.placement Placement applied to popper
3947 * @property {String} data.originalPlacement Placement originally defined on init
3948 * @property {Boolean} data.flipped True if popper has been flipped by flip modifier
3949 * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper
3950 * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier
3951 * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)
3952 * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)
3953 * @property {Object} data.boundaries Offsets of the popper boundaries
3954 * @property {Object} data.offsets The measurements of popper, reference and arrow elements
3955 * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values
3956 * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values
3957 * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0
3958 */
3959
3960 /**
3961 * Default options provided to Popper.js constructor.<br />
3962 * These can be overridden using the `options` argument of Popper.js.<br />
3963 * To override an option, simply pass an object with the same
3964 * structure of the `options` object, as the 3rd argument. For example:
3965 * ```
3966 * new Popper(ref, pop, {
3967 * modifiers: {
3968 * preventOverflow: { enabled: false }
3969 * }
3970 * })
3971 * ```
3972 * @type {Object}
3973 * @static
3974 * @memberof Popper
3975 */
3976 var Defaults = {
3977 /**
3978 * Popper's placement.
3979 * @prop {Popper.placements} placement='bottom'
3980 */
3981 placement: 'bottom',
3982
3983 /**
3984 * Set this to true if you want popper to position it self in 'fixed' mode
3985 * @prop {Boolean} positionFixed=false
3986 */
3987 positionFixed: false,
3988
3989 /**
3990 * Whether events (resize, scroll) are initially enabled.
3991 * @prop {Boolean} eventsEnabled=true
3992 */
3993 eventsEnabled: true,
3994
3995 /**
3996 * Set to true if you want to automatically remove the popper when
3997 * you call the `destroy` method.
3998 * @prop {Boolean} removeOnDestroy=false
3999 */
4000 removeOnDestroy: false,
4001
4002 /**
4003 * Callback called when the popper is created.<br />
4004 * By default, it is set to no-op.<br />
4005 * Access Popper.js instance with `data.instance`.
4006 * @prop {onCreate}
4007 */
4008 onCreate: function onCreate() {},
4009
4010 /**
4011 * Callback called when the popper is updated. This callback is not called
4012 * on the initialization/creation of the popper, but only on subsequent
4013 * updates.<br />
4014 * By default, it is set to no-op.<br />
4015 * Access Popper.js instance with `data.instance`.
4016 * @prop {onUpdate}
4017 */
4018 onUpdate: function onUpdate() {},
4019
4020 /**
4021 * List of modifiers used to modify the offsets before they are applied to the popper.
4022 * They provide most of the functionalities of Popper.js.
4023 * @prop {modifiers}
4024 */
4025 modifiers: modifiers
4026 };
4027
4028 /**
4029 * @callback onCreate
4030 * @param {dataObject} data
4031 */
4032
4033 /**
4034 * @callback onUpdate
4035 * @param {dataObject} data
4036 */
4037
4038 // Utils
4039 // Methods
4040 var Popper = function () {
4041 /**
4042 * Creates a new Popper.js instance.
4043 * @class Popper
4044 * @param {Element|referenceObject} reference - The reference element used to position the popper
4045 * @param {Element} popper - The HTML / XML element used as the popper
4046 * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)
4047 * @return {Object} instance - The generated Popper.js instance
4048 */
4049 function Popper(reference, popper) {
4050 var _this = this;
4051
4052 var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
4053 classCallCheck(this, Popper);
4054
4055 this.scheduleUpdate = function () {
4056 return requestAnimationFrame(_this.update);
4057 };
4058
4059 // make update() debounced, so that it only runs at most once-per-tick
4060 this.update = debounce(this.update.bind(this));
4061
4062 // with {} we create a new object with the options inside it
4063 this.options = _extends({}, Popper.Defaults, options);
4064
4065 // init state
4066 this.state = {
4067 isDestroyed: false,
4068 isCreated: false,
4069 scrollParents: []
4070 };
4071
4072 // get reference and popper elements (allow jQuery wrappers)
4073 this.reference = reference && reference.jquery ? reference[0] : reference;
4074 this.popper = popper && popper.jquery ? popper[0] : popper;
4075
4076 // Deep merge modifiers options
4077 this.options.modifiers = {};
4078 Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {
4079 _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
4080 });
4081
4082 // Refactoring modifiers' list (Object => Array)
4083 this.modifiers = Object.keys(this.options.modifiers).map(function (name) {
4084 return _extends({
4085 name: name
4086 }, _this.options.modifiers[name]);
4087 })
4088 // sort the modifiers by order
4089 .sort(function (a, b) {
4090 return a.order - b.order;
4091 });
4092
4093 // modifiers have the ability to execute arbitrary code when Popper.js get inited
4094 // such code is executed in the same order of its modifier
4095 // they could add new properties to their options configuration
4096 // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!
4097 this.modifiers.forEach(function (modifierOptions) {
4098 if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
4099 modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
4100 }
4101 });
4102
4103 // fire the first update to position the popper in the right place
4104 this.update();
4105
4106 var eventsEnabled = this.options.eventsEnabled;
4107 if (eventsEnabled) {
4108 // setup event listeners, they will take care of update the position in specific situations
4109 this.enableEventListeners();
4110 }
4111
4112 this.state.eventsEnabled = eventsEnabled;
4113 }
4114
4115 // We can't use class properties because they don't get listed in the
4116 // class prototype and break stuff like Sinon stubs
4117
4118
4119 createClass(Popper, [{
4120 key: 'update',
4121 value: function update$$1() {
4122 return update.call(this);
4123 }
4124 }, {
4125 key: 'destroy',
4126 value: function destroy$$1() {
4127 return destroy.call(this);
4128 }
4129 }, {
4130 key: 'enableEventListeners',
4131 value: function enableEventListeners$$1() {
4132 return enableEventListeners.call(this);
4133 }
4134 }, {
4135 key: 'disableEventListeners',
4136 value: function disableEventListeners$$1() {
4137 return disableEventListeners.call(this);
4138 }
4139
4140 /**
4141 * Schedules an update. It will run on the next UI update available.
4142 * @method scheduleUpdate
4143 * @memberof Popper
4144 */
4145
4146
4147 /**
4148 * Collection of utilities useful when writing custom modifiers.
4149 * Starting from version 1.7, this method is available only if you
4150 * include `popper-utils.js` before `popper.js`.
4151 *
4152 * **DEPRECATION**: This way to access PopperUtils is deprecated
4153 * and will be removed in v2! Use the PopperUtils module directly instead.
4154 * Due to the high instability of the methods contained in Utils, we can't
4155 * guarantee them to follow semver. Use them at your own risk!
4156 * @static
4157 * @private
4158 * @type {Object}
4159 * @deprecated since version 1.8
4160 * @member Utils
4161 * @memberof Popper
4162 */
4163
4164 }]);
4165 return Popper;
4166 }();
4167
4168 /**
4169 * The `referenceObject` is an object that provides an interface compatible with Popper.js
4170 * and lets you use it as replacement of a real DOM node.<br />
4171 * You can use this method to position a popper relatively to a set of coordinates
4172 * in case you don't have a DOM node to use as reference.
4173 *
4174 * ```
4175 * new Popper(referenceObject, popperNode);
4176 * ```
4177 *
4178 * NB: This feature isn't supported in Internet Explorer 10.
4179 * @name referenceObject
4180 * @property {Function} data.getBoundingClientRect
4181 * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.
4182 * @property {number} data.clientWidth
4183 * An ES6 getter that will return the width of the virtual reference element.
4184 * @property {number} data.clientHeight
4185 * An ES6 getter that will return the height of the virtual reference element.
4186 */
4187
4188
4189 Popper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;
4190 Popper.placements = placements;
4191 Popper.Defaults = Defaults;
4192
4193 /**
4194 * ------------------------------------------------------------------------
4195 * Constants
4196 * ------------------------------------------------------------------------
4197 */
4198
4199 var NAME$4 = 'dropdown';
4200 var VERSION$4 = '4.4.1';
4201 var DATA_KEY$4 = 'bs.dropdown';
4202 var EVENT_KEY$4 = "." + DATA_KEY$4;
4203 var DATA_API_KEY$4 = '.data-api';
4204 var JQUERY_NO_CONFLICT$4 = $.fn[NAME$4];
4205 var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key
4206
4207 var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key
4208
4209 var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key
4210
4211 var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key
4212
4213 var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key
4214
4215 var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse)
4216
4217 var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE);
4218 var Event$4 = {
4219 HIDE: "hide" + EVENT_KEY$4,
4220 HIDDEN: "hidden" + EVENT_KEY$4,
4221 SHOW: "show" + EVENT_KEY$4,
4222 SHOWN: "shown" + EVENT_KEY$4,
4223 CLICK: "click" + EVENT_KEY$4,
4224 CLICK_DATA_API: "click" + EVENT_KEY$4 + DATA_API_KEY$4,
4225 KEYDOWN_DATA_API: "keydown" + EVENT_KEY$4 + DATA_API_KEY$4,
4226 KEYUP_DATA_API: "keyup" + EVENT_KEY$4 + DATA_API_KEY$4
4227 };
4228 var ClassName$4 = {
4229 DISABLED: 'disabled',
4230 SHOW: 'show',
4231 DROPUP: 'dropup',
4232 DROPRIGHT: 'dropright',
4233 DROPLEFT: 'dropleft',
4234 MENURIGHT: 'dropdown-menu-right',
4235 MENULEFT: 'dropdown-menu-left',
4236 POSITION_STATIC: 'position-static'
4237 };
4238 var Selector$4 = {
4239 DATA_TOGGLE: '[data-toggle="dropdown"]',
4240 FORM_CHILD: '.dropdown form',
4241 MENU: '.dropdown-menu',
4242 NAVBAR_NAV: '.navbar-nav',
4243 VISIBLE_ITEMS: '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'
4244 };
4245 var AttachmentMap = {
4246 TOP: 'top-start',
4247 TOPEND: 'top-end',
4248 BOTTOM: 'bottom-start',
4249 BOTTOMEND: 'bottom-end',
4250 RIGHT: 'right-start',
4251 RIGHTEND: 'right-end',
4252 LEFT: 'left-start',
4253 LEFTEND: 'left-end'
4254 };
4255 var Default$2 = {
4256 offset: 0,
4257 flip: true,
4258 boundary: 'scrollParent',
4259 reference: 'toggle',
4260 display: 'dynamic',
4261 popperConfig: null
4262 };
4263 var DefaultType$2 = {
4264 offset: '(number|string|function)',
4265 flip: 'boolean',
4266 boundary: '(string|element)',
4267 reference: '(string|element)',
4268 display: 'string',
4269 popperConfig: '(null|object)'
4270 };
4271 /**
4272 * ------------------------------------------------------------------------
4273 * Class Definition
4274 * ------------------------------------------------------------------------
4275 */
4276
4277 var Dropdown =
4278 /*#__PURE__*/
4279 function () {
4280 function Dropdown(element, config) {
4281 this._element = element;
4282 this._popper = null;
4283 this._config = this._getConfig(config);
4284 this._menu = this._getMenuElement();
4285 this._inNavbar = this._detectNavbar();
4286
4287 this._addEventListeners();
4288 } // Getters
4289
4290
4291 var _proto = Dropdown.prototype;
4292
4293 // Public
4294 _proto.toggle = function toggle() {
4295 if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED)) {
4296 return;
4297 }
4298
4299 var isActive = $(this._menu).hasClass(ClassName$4.SHOW);
4300
4301 Dropdown._clearMenus();
4302
4303 if (isActive) {
4304 return;
4305 }
4306
4307 this.show(true);
4308 };
4309
4310 _proto.show = function show(usePopper) {
4311 if (usePopper === void 0) {
4312 usePopper = false;
4313 }
4314
4315 if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED) || $(this._menu).hasClass(ClassName$4.SHOW)) {
4316 return;
4317 }
4318
4319 var relatedTarget = {
4320 relatedTarget: this._element
4321 };
4322 var showEvent = $.Event(Event$4.SHOW, relatedTarget);
4323
4324 var parent = Dropdown._getParentFromElement(this._element);
4325
4326 $(parent).trigger(showEvent);
4327
4328 if (showEvent.isDefaultPrevented()) {
4329 return;
4330 } // Disable totally Popper.js for Dropdown in Navbar
4331
4332
4333 if (!this._inNavbar && usePopper) {
4334 /**
4335 * Check for Popper dependency
4336 * Popper - https://popper.js.org
4337 */
4338 if (typeof Popper === 'undefined') {
4339 throw new TypeError('Bootstrap\'s dropdowns require Popper.js (https://popper.js.org/)');
4340 }
4341
4342 var referenceElement = this._element;
4343
4344 if (this._config.reference === 'parent') {
4345 referenceElement = parent;
4346 } else if (Util.isElement(this._config.reference)) {
4347 referenceElement = this._config.reference; // Check if it's jQuery element
4348
4349 if (typeof this._config.reference.jquery !== 'undefined') {
4350 referenceElement = this._config.reference[0];
4351 }
4352 } // If boundary is not `scrollParent`, then set position to `static`
4353 // to allow the menu to "escape" the scroll parent's boundaries
4354 // https://github.com/twbs/bootstrap/issues/24251
4355
4356
4357 if (this._config.boundary !== 'scrollParent') {
4358 $(parent).addClass(ClassName$4.POSITION_STATIC);
4359 }
4360
4361 this._popper = new Popper(referenceElement, this._menu, this._getPopperConfig());
4362 } // If this is a touch-enabled device we add extra
4363 // empty mouseover listeners to the body's immediate children;
4364 // only needed because of broken event delegation on iOS
4365 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
4366
4367
4368 if ('ontouchstart' in document.documentElement && $(parent).closest(Selector$4.NAVBAR_NAV).length === 0) {
4369 $(document.body).children().on('mouseover', null, $.noop);
4370 }
4371
4372 this._element.focus();
4373
4374 this._element.setAttribute('aria-expanded', true);
4375
4376 $(this._menu).toggleClass(ClassName$4.SHOW);
4377 $(parent).toggleClass(ClassName$4.SHOW).trigger($.Event(Event$4.SHOWN, relatedTarget));
4378 };
4379
4380 _proto.hide = function hide() {
4381 if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED) || !$(this._menu).hasClass(ClassName$4.SHOW)) {
4382 return;
4383 }
4384
4385 var relatedTarget = {
4386 relatedTarget: this._element
4387 };
4388 var hideEvent = $.Event(Event$4.HIDE, relatedTarget);
4389
4390 var parent = Dropdown._getParentFromElement(this._element);
4391
4392 $(parent).trigger(hideEvent);
4393
4394 if (hideEvent.isDefaultPrevented()) {
4395 return;
4396 }
4397
4398 if (this._popper) {
4399 this._popper.destroy();
4400 }
4401
4402 $(this._menu).toggleClass(ClassName$4.SHOW);
4403 $(parent).toggleClass(ClassName$4.SHOW).trigger($.Event(Event$4.HIDDEN, relatedTarget));
4404 };
4405
4406 _proto.dispose = function dispose() {
4407 $.removeData(this._element, DATA_KEY$4);
4408 $(this._element).off(EVENT_KEY$4);
4409 this._element = null;
4410 this._menu = null;
4411
4412 if (this._popper !== null) {
4413 this._popper.destroy();
4414
4415 this._popper = null;
4416 }
4417 };
4418
4419 _proto.update = function update() {
4420 this._inNavbar = this._detectNavbar();
4421
4422 if (this._popper !== null) {
4423 this._popper.scheduleUpdate();
4424 }
4425 } // Private
4426 ;
4427
4428 _proto._addEventListeners = function _addEventListeners() {
4429 var _this = this;
4430
4431 $(this._element).on(Event$4.CLICK, function (event) {
4432 event.preventDefault();
4433 event.stopPropagation();
4434
4435 _this.toggle();
4436 });
4437 };
4438
4439 _proto._getConfig = function _getConfig(config) {
4440 config = _objectSpread2({}, this.constructor.Default, {}, $(this._element).data(), {}, config);
4441 Util.typeCheckConfig(NAME$4, config, this.constructor.DefaultType);
4442 return config;
4443 };
4444
4445 _proto._getMenuElement = function _getMenuElement() {
4446 if (!this._menu) {
4447 var parent = Dropdown._getParentFromElement(this._element);
4448
4449 if (parent) {
4450 this._menu = parent.querySelector(Selector$4.MENU);
4451 }
4452 }
4453
4454 return this._menu;
4455 };
4456
4457 _proto._getPlacement = function _getPlacement() {
4458 var $parentDropdown = $(this._element.parentNode);
4459 var placement = AttachmentMap.BOTTOM; // Handle dropup
4460
4461 if ($parentDropdown.hasClass(ClassName$4.DROPUP)) {
4462 placement = AttachmentMap.TOP;
4463
4464 if ($(this._menu).hasClass(ClassName$4.MENURIGHT)) {
4465 placement = AttachmentMap.TOPEND;
4466 }
4467 } else if ($parentDropdown.hasClass(ClassName$4.DROPRIGHT)) {
4468 placement = AttachmentMap.RIGHT;
4469 } else if ($parentDropdown.hasClass(ClassName$4.DROPLEFT)) {
4470 placement = AttachmentMap.LEFT;
4471 } else if ($(this._menu).hasClass(ClassName$4.MENURIGHT)) {
4472 placement = AttachmentMap.BOTTOMEND;
4473 }
4474
4475 return placement;
4476 };
4477
4478 _proto._detectNavbar = function _detectNavbar() {
4479 return $(this._element).closest('.navbar').length > 0;
4480 };
4481
4482 _proto._getOffset = function _getOffset() {
4483 var _this2 = this;
4484
4485 var offset = {};
4486
4487 if (typeof this._config.offset === 'function') {
4488 offset.fn = function (data) {
4489 data.offsets = _objectSpread2({}, data.offsets, {}, _this2._config.offset(data.offsets, _this2._element) || {});
4490 return data;
4491 };
4492 } else {
4493 offset.offset = this._config.offset;
4494 }
4495
4496 return offset;
4497 };
4498
4499 _proto._getPopperConfig = function _getPopperConfig() {
4500 var popperConfig = {
4501 placement: this._getPlacement(),
4502 modifiers: {
4503 offset: this._getOffset(),
4504 flip: {
4505 enabled: this._config.flip
4506 },
4507 preventOverflow: {
4508 boundariesElement: this._config.boundary
4509 }
4510 }
4511 }; // Disable Popper.js if we have a static display
4512
4513 if (this._config.display === 'static') {
4514 popperConfig.modifiers.applyStyle = {
4515 enabled: false
4516 };
4517 }
4518
4519 return _objectSpread2({}, popperConfig, {}, this._config.popperConfig);
4520 } // Static
4521 ;
4522
4523 Dropdown._jQueryInterface = function _jQueryInterface(config) {
4524 return this.each(function () {
4525 var data = $(this).data(DATA_KEY$4);
4526
4527 var _config = typeof config === 'object' ? config : null;
4528
4529 if (!data) {
4530 data = new Dropdown(this, _config);
4531 $(this).data(DATA_KEY$4, data);
4532 }
4533
4534 if (typeof config === 'string') {
4535 if (typeof data[config] === 'undefined') {
4536 throw new TypeError("No method named \"" + config + "\"");
4537 }
4538
4539 data[config]();
4540 }
4541 });
4542 };
4543
4544 Dropdown._clearMenus = function _clearMenus(event) {
4545 if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) {
4546 return;
4547 }
4548
4549 var toggles = [].slice.call(document.querySelectorAll(Selector$4.DATA_TOGGLE));
4550
4551 for (var i = 0, len = toggles.length; i < len; i++) {
4552 var parent = Dropdown._getParentFromElement(toggles[i]);
4553
4554 var context = $(toggles[i]).data(DATA_KEY$4);
4555 var relatedTarget = {
4556 relatedTarget: toggles[i]
4557 };
4558
4559 if (event && event.type === 'click') {
4560 relatedTarget.clickEvent = event;
4561 }
4562
4563 if (!context) {
4564 continue;
4565 }
4566
4567 var dropdownMenu = context._menu;
4568
4569 if (!$(parent).hasClass(ClassName$4.SHOW)) {
4570 continue;
4571 }
4572
4573 if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $.contains(parent, event.target)) {
4574 continue;
4575 }
4576
4577 var hideEvent = $.Event(Event$4.HIDE, relatedTarget);
4578 $(parent).trigger(hideEvent);
4579
4580 if (hideEvent.isDefaultPrevented()) {
4581 continue;
4582 } // If this is a touch-enabled device we remove the extra
4583 // empty mouseover listeners we added for iOS support
4584
4585
4586 if ('ontouchstart' in document.documentElement) {
4587 $(document.body).children().off('mouseover', null, $.noop);
4588 }
4589
4590 toggles[i].setAttribute('aria-expanded', 'false');
4591
4592 if (context._popper) {
4593 context._popper.destroy();
4594 }
4595
4596 $(dropdownMenu).removeClass(ClassName$4.SHOW);
4597 $(parent).removeClass(ClassName$4.SHOW).trigger($.Event(Event$4.HIDDEN, relatedTarget));
4598 }
4599 };
4600
4601 Dropdown._getParentFromElement = function _getParentFromElement(element) {
4602 var parent;
4603 var selector = Util.getSelectorFromElement(element);
4604
4605 if (selector) {
4606 parent = document.querySelector(selector);
4607 }
4608
4609 return parent || element.parentNode;
4610 } // eslint-disable-next-line complexity
4611 ;
4612
4613 Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) {
4614 // If not input/textarea:
4615 // - And not a key in REGEXP_KEYDOWN => not a dropdown command
4616 // If input/textarea:
4617 // - If space key => not a dropdown command
4618 // - If key is other than escape
4619 // - If key is not up or down => not a dropdown command
4620 // - If trigger inside the menu => not a dropdown command
4621 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)) {
4622 return;
4623 }
4624
4625 event.preventDefault();
4626 event.stopPropagation();
4627
4628 if (this.disabled || $(this).hasClass(ClassName$4.DISABLED)) {
4629 return;
4630 }
4631
4632 var parent = Dropdown._getParentFromElement(this);
4633
4634 var isActive = $(parent).hasClass(ClassName$4.SHOW);
4635
4636 if (!isActive && event.which === ESCAPE_KEYCODE) {
4637 return;
4638 }
4639
4640 if (!isActive || isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) {
4641 if (event.which === ESCAPE_KEYCODE) {
4642 var toggle = parent.querySelector(Selector$4.DATA_TOGGLE);
4643 $(toggle).trigger('focus');
4644 }
4645
4646 $(this).trigger('click');
4647 return;
4648 }
4649
4650 var items = [].slice.call(parent.querySelectorAll(Selector$4.VISIBLE_ITEMS)).filter(function (item) {
4651 return $(item).is(':visible');
4652 });
4653
4654 if (items.length === 0) {
4655 return;
4656 }
4657
4658 var index = items.indexOf(event.target);
4659
4660 if (event.which === ARROW_UP_KEYCODE && index > 0) {
4661 // Up
4662 index--;
4663 }
4664
4665 if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) {
4666 // Down
4667 index++;
4668 }
4669
4670 if (index < 0) {
4671 index = 0;
4672 }
4673
4674 items[index].focus();
4675 };
4676
4677 _createClass(Dropdown, null, [{
4678 key: "VERSION",
4679 get: function get() {
4680 return VERSION$4;
4681 }
4682 }, {
4683 key: "Default",
4684 get: function get() {
4685 return Default$2;
4686 }
4687 }, {
4688 key: "DefaultType",
4689 get: function get() {
4690 return DefaultType$2;
4691 }
4692 }]);
4693
4694 return Dropdown;
4695 }();
4696 /**
4697 * ------------------------------------------------------------------------
4698 * Data Api implementation
4699 * ------------------------------------------------------------------------
4700 */
4701
4702
4703 $(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) {
4704 event.preventDefault();
4705 event.stopPropagation();
4706
4707 Dropdown._jQueryInterface.call($(this), 'toggle');
4708 }).on(Event$4.CLICK_DATA_API, Selector$4.FORM_CHILD, function (e) {
4709 e.stopPropagation();
4710 });
4711 /**
4712 * ------------------------------------------------------------------------
4713 * jQuery
4714 * ------------------------------------------------------------------------
4715 */
4716
4717 $.fn[NAME$4] = Dropdown._jQueryInterface;
4718 $.fn[NAME$4].Constructor = Dropdown;
4719
4720 $.fn[NAME$4].noConflict = function () {
4721 $.fn[NAME$4] = JQUERY_NO_CONFLICT$4;
4722 return Dropdown._jQueryInterface;
4723 };
4724
4725 /**
4726 * ------------------------------------------------------------------------
4727 * Constants
4728 * ------------------------------------------------------------------------
4729 */
4730
4731 var NAME$5 = 'modal';
4732 var VERSION$5 = '4.4.1';
4733 var DATA_KEY$5 = 'bs.modal';
4734 var EVENT_KEY$5 = "." + DATA_KEY$5;
4735 var DATA_API_KEY$5 = '.data-api';
4736 var JQUERY_NO_CONFLICT$5 = $.fn[NAME$5];
4737 var ESCAPE_KEYCODE$1 = 27; // KeyboardEvent.which value for Escape (Esc) key
4738
4739 var Default$3 = {
4740 backdrop: true,
4741 keyboard: true,
4742 focus: true,
4743 show: true
4744 };
4745 var DefaultType$3 = {
4746 backdrop: '(boolean|string)',
4747 keyboard: 'boolean',
4748 focus: 'boolean',
4749 show: 'boolean'
4750 };
4751 var Event$5 = {
4752 HIDE: "hide" + EVENT_KEY$5,
4753 HIDE_PREVENTED: "hidePrevented" + EVENT_KEY$5,
4754 HIDDEN: "hidden" + EVENT_KEY$5,
4755 SHOW: "show" + EVENT_KEY$5,
4756 SHOWN: "shown" + EVENT_KEY$5,
4757 FOCUSIN: "focusin" + EVENT_KEY$5,
4758 RESIZE: "resize" + EVENT_KEY$5,
4759 CLICK_DISMISS: "click.dismiss" + EVENT_KEY$5,
4760 KEYDOWN_DISMISS: "keydown.dismiss" + EVENT_KEY$5,
4761 MOUSEUP_DISMISS: "mouseup.dismiss" + EVENT_KEY$5,
4762 MOUSEDOWN_DISMISS: "mousedown.dismiss" + EVENT_KEY$5,
4763 CLICK_DATA_API: "click" + EVENT_KEY$5 + DATA_API_KEY$5
4764 };
4765 var ClassName$5 = {
4766 SCROLLABLE: 'modal-dialog-scrollable',
4767 SCROLLBAR_MEASURER: 'modal-scrollbar-measure',
4768 BACKDROP: 'modal-backdrop',
4769 OPEN: 'modal-open',
4770 FADE: 'fade',
4771 SHOW: 'show',
4772 STATIC: 'modal-static'
4773 };
4774 var Selector$5 = {
4775 DIALOG: '.modal-dialog',
4776 MODAL_BODY: '.modal-body',
4777 DATA_TOGGLE: '[data-toggle="modal"]',
4778 DATA_DISMISS: '[data-dismiss="modal"]',
4779 FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',
4780 STICKY_CONTENT: '.sticky-top'
4781 };
4782 /**
4783 * ------------------------------------------------------------------------
4784 * Class Definition
4785 * ------------------------------------------------------------------------
4786 */
4787
4788 var Modal =
4789 /*#__PURE__*/
4790 function () {
4791 function Modal(element, config) {
4792 this._config = this._getConfig(config);
4793 this._element = element;
4794 this._dialog = element.querySelector(Selector$5.DIALOG);
4795 this._backdrop = null;
4796 this._isShown = false;
4797 this._isBodyOverflowing = false;
4798 this._ignoreBackdropClick = false;
4799 this._isTransitioning = false;
4800 this._scrollbarWidth = 0;
4801 } // Getters
4802
4803
4804 var _proto = Modal.prototype;
4805
4806 // Public
4807 _proto.toggle = function toggle(relatedTarget) {
4808 return this._isShown ? this.hide() : this.show(relatedTarget);
4809 };
4810
4811 _proto.show = function show(relatedTarget) {
4812 var _this = this;
4813
4814 if (this._isShown || this._isTransitioning) {
4815 return;
4816 }
4817
4818 if ($(this._element).hasClass(ClassName$5.FADE)) {
4819 this._isTransitioning = true;
4820 }
4821
4822 var showEvent = $.Event(Event$5.SHOW, {
4823 relatedTarget: relatedTarget
4824 });
4825 $(this._element).trigger(showEvent);
4826
4827 if (this._isShown || showEvent.isDefaultPrevented()) {
4828 return;
4829 }
4830
4831 this._isShown = true;
4832
4833 this._checkScrollbar();
4834
4835 this._setScrollbar();
4836
4837 this._adjustDialog();
4838
4839 this._setEscapeEvent();
4840
4841 this._setResizeEvent();
4842
4843 $(this._element).on(Event$5.CLICK_DISMISS, Selector$5.DATA_DISMISS, function (event) {
4844 return _this.hide(event);
4845 });
4846 $(this._dialog).on(Event$5.MOUSEDOWN_DISMISS, function () {
4847 $(_this._element).one(Event$5.MOUSEUP_DISMISS, function (event) {
4848 if ($(event.target).is(_this._element)) {
4849 _this._ignoreBackdropClick = true;
4850 }
4851 });
4852 });
4853
4854 this._showBackdrop(function () {
4855 return _this._showElement(relatedTarget);
4856 });
4857 };
4858
4859 _proto.hide = function hide(event) {
4860 var _this2 = this;
4861
4862 if (event) {
4863 event.preventDefault();
4864 }
4865
4866 if (!this._isShown || this._isTransitioning) {
4867 return;
4868 }
4869
4870 var hideEvent = $.Event(Event$5.HIDE);
4871 $(this._element).trigger(hideEvent);
4872
4873 if (!this._isShown || hideEvent.isDefaultPrevented()) {
4874 return;
4875 }
4876
4877 this._isShown = false;
4878 var transition = $(this._element).hasClass(ClassName$5.FADE);
4879
4880 if (transition) {
4881 this._isTransitioning = true;
4882 }
4883
4884 this._setEscapeEvent();
4885
4886 this._setResizeEvent();
4887
4888 $(document).off(Event$5.FOCUSIN);
4889 $(this._element).removeClass(ClassName$5.SHOW);
4890 $(this._element).off(Event$5.CLICK_DISMISS);
4891 $(this._dialog).off(Event$5.MOUSEDOWN_DISMISS);
4892
4893 if (transition) {
4894 var transitionDuration = Util.getTransitionDurationFromElement(this._element);
4895 $(this._element).one(Util.TRANSITION_END, function (event) {
4896 return _this2._hideModal(event);
4897 }).emulateTransitionEnd(transitionDuration);
4898 } else {
4899 this._hideModal();
4900 }
4901 };
4902
4903 _proto.dispose = function dispose() {
4904 [window, this._element, this._dialog].forEach(function (htmlElement) {
4905 return $(htmlElement).off(EVENT_KEY$5);
4906 });
4907 /**
4908 * `document` has 2 events `Event.FOCUSIN` and `Event.CLICK_DATA_API`
4909 * Do not move `document` in `htmlElements` array
4910 * It will remove `Event.CLICK_DATA_API` event that should remain
4911 */
4912
4913 $(document).off(Event$5.FOCUSIN);
4914 $.removeData(this._element, DATA_KEY$5);
4915 this._config = null;
4916 this._element = null;
4917 this._dialog = null;
4918 this._backdrop = null;
4919 this._isShown = null;
4920 this._isBodyOverflowing = null;
4921 this._ignoreBackdropClick = null;
4922 this._isTransitioning = null;
4923 this._scrollbarWidth = null;
4924 };
4925
4926 _proto.handleUpdate = function handleUpdate() {
4927 this._adjustDialog();
4928 } // Private
4929 ;
4930
4931 _proto._getConfig = function _getConfig(config) {
4932 config = _objectSpread2({}, Default$3, {}, config);
4933 Util.typeCheckConfig(NAME$5, config, DefaultType$3);
4934 return config;
4935 };
4936
4937 _proto._triggerBackdropTransition = function _triggerBackdropTransition() {
4938 var _this3 = this;
4939
4940 if (this._config.backdrop === 'static') {
4941 var hideEventPrevented = $.Event(Event$5.HIDE_PREVENTED);
4942 $(this._element).trigger(hideEventPrevented);
4943
4944 if (hideEventPrevented.defaultPrevented) {
4945 return;
4946 }
4947
4948 this._element.classList.add(ClassName$5.STATIC);
4949
4950 var modalTransitionDuration = Util.getTransitionDurationFromElement(this._element);
4951 $(this._element).one(Util.TRANSITION_END, function () {
4952 _this3._element.classList.remove(ClassName$5.STATIC);
4953 }).emulateTransitionEnd(modalTransitionDuration);
4954
4955 this._element.focus();
4956 } else {
4957 this.hide();
4958 }
4959 };
4960
4961 _proto._showElement = function _showElement(relatedTarget) {
4962 var _this4 = this;
4963
4964 var transition = $(this._element).hasClass(ClassName$5.FADE);
4965 var modalBody = this._dialog ? this._dialog.querySelector(Selector$5.MODAL_BODY) : null;
4966
4967 if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
4968 // Don't move modal's DOM position
4969 document.body.appendChild(this._element);
4970 }
4971
4972 this._element.style.display = 'block';
4973
4974 this._element.removeAttribute('aria-hidden');
4975
4976 this._element.setAttribute('aria-modal', true);
4977
4978 if ($(this._dialog).hasClass(ClassName$5.SCROLLABLE) && modalBody) {
4979 modalBody.scrollTop = 0;
4980 } else {
4981 this._element.scrollTop = 0;
4982 }
4983
4984 if (transition) {
4985 Util.reflow(this._element);
4986 }
4987
4988 $(this._element).addClass(ClassName$5.SHOW);
4989
4990 if (this._config.focus) {
4991 this._enforceFocus();
4992 }
4993
4994 var shownEvent = $.Event(Event$5.SHOWN, {
4995 relatedTarget: relatedTarget
4996 });
4997
4998 var transitionComplete = function transitionComplete() {
4999 if (_this4._config.focus) {
5000 _this4._element.focus();
5001 }
5002
5003 _this4._isTransitioning = false;
5004 $(_this4._element).trigger(shownEvent);
5005 };
5006
5007 if (transition) {
5008 var transitionDuration = Util.getTransitionDurationFromElement(this._dialog);
5009 $(this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(transitionDuration);
5010 } else {
5011 transitionComplete();
5012 }
5013 };
5014
5015 _proto._enforceFocus = function _enforceFocus() {
5016 var _this5 = this;
5017
5018 $(document).off(Event$5.FOCUSIN) // Guard against infinite focus loop
5019 .on(Event$5.FOCUSIN, function (event) {
5020 if (document !== event.target && _this5._element !== event.target && $(_this5._element).has(event.target).length === 0) {
5021 _this5._element.focus();
5022 }
5023 });
5024 };
5025
5026 _proto._setEscapeEvent = function _setEscapeEvent() {
5027 var _this6 = this;
5028
5029 if (this._isShown && this._config.keyboard) {
5030 $(this._element).on(Event$5.KEYDOWN_DISMISS, function (event) {
5031 if (event.which === ESCAPE_KEYCODE$1) {
5032 _this6._triggerBackdropTransition();
5033 }
5034 });
5035 } else if (!this._isShown) {
5036 $(this._element).off(Event$5.KEYDOWN_DISMISS);
5037 }
5038 };
5039
5040 _proto._setResizeEvent = function _setResizeEvent() {
5041 var _this7 = this;
5042
5043 if (this._isShown) {
5044 $(window).on(Event$5.RESIZE, function (event) {
5045 return _this7.handleUpdate(event);
5046 });
5047 } else {
5048 $(window).off(Event$5.RESIZE);
5049 }
5050 };
5051
5052 _proto._hideModal = function _hideModal() {
5053 var _this8 = this;
5054
5055 this._element.style.display = 'none';
5056
5057 this._element.setAttribute('aria-hidden', true);
5058
5059 this._element.removeAttribute('aria-modal');
5060
5061 this._isTransitioning = false;
5062
5063 this._showBackdrop(function () {
5064 $(document.body).removeClass(ClassName$5.OPEN);
5065
5066 _this8._resetAdjustments();
5067
5068 _this8._resetScrollbar();
5069
5070 $(_this8._element).trigger(Event$5.HIDDEN);
5071 });
5072 };
5073
5074 _proto._removeBackdrop = function _removeBackdrop() {
5075 if (this._backdrop) {
5076 $(this._backdrop).remove();
5077 this._backdrop = null;
5078 }
5079 };
5080
5081 _proto._showBackdrop = function _showBackdrop(callback) {
5082 var _this9 = this;
5083
5084 var animate = $(this._element).hasClass(ClassName$5.FADE) ? ClassName$5.FADE : '';
5085
5086 if (this._isShown && this._config.backdrop) {
5087 this._backdrop = document.createElement('div');
5088 this._backdrop.className = ClassName$5.BACKDROP;
5089
5090 if (animate) {
5091 this._backdrop.classList.add(animate);
5092 }
5093
5094 $(this._backdrop).appendTo(document.body);
5095 $(this._element).on(Event$5.CLICK_DISMISS, function (event) {
5096 if (_this9._ignoreBackdropClick) {
5097 _this9._ignoreBackdropClick = false;
5098 return;
5099 }
5100
5101 if (event.target !== event.currentTarget) {
5102 return;
5103 }
5104
5105 _this9._triggerBackdropTransition();
5106 });
5107
5108 if (animate) {
5109 Util.reflow(this._backdrop);
5110 }
5111
5112 $(this._backdrop).addClass(ClassName$5.SHOW);
5113
5114 if (!callback) {
5115 return;
5116 }
5117
5118 if (!animate) {
5119 callback();
5120 return;
5121 }
5122
5123 var backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop);
5124 $(this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(backdropTransitionDuration);
5125 } else if (!this._isShown && this._backdrop) {
5126 $(this._backdrop).removeClass(ClassName$5.SHOW);
5127
5128 var callbackRemove = function callbackRemove() {
5129 _this9._removeBackdrop();
5130
5131 if (callback) {
5132 callback();
5133 }
5134 };
5135
5136 if ($(this._element).hasClass(ClassName$5.FADE)) {
5137 var _backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop);
5138
5139 $(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(_backdropTransitionDuration);
5140 } else {
5141 callbackRemove();
5142 }
5143 } else if (callback) {
5144 callback();
5145 }
5146 } // ----------------------------------------------------------------------
5147 // the following methods are used to handle overflowing modals
5148 // todo (fat): these should probably be refactored out of modal.js
5149 // ----------------------------------------------------------------------
5150 ;
5151
5152 _proto._adjustDialog = function _adjustDialog() {
5153 var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
5154
5155 if (!this._isBodyOverflowing && isModalOverflowing) {
5156 this._element.style.paddingLeft = this._scrollbarWidth + "px";
5157 }
5158
5159 if (this._isBodyOverflowing && !isModalOverflowing) {
5160 this._element.style.paddingRight = this._scrollbarWidth + "px";
5161 }
5162 };
5163
5164 _proto._resetAdjustments = function _resetAdjustments() {
5165 this._element.style.paddingLeft = '';
5166 this._element.style.paddingRight = '';
5167 };
5168
5169 _proto._checkScrollbar = function _checkScrollbar() {
5170 var rect = document.body.getBoundingClientRect();
5171 this._isBodyOverflowing = rect.left + rect.right < window.innerWidth;
5172 this._scrollbarWidth = this._getScrollbarWidth();
5173 };
5174
5175 _proto._setScrollbar = function _setScrollbar() {
5176 var _this10 = this;
5177
5178 if (this._isBodyOverflowing) {
5179 // Note: DOMNode.style.paddingRight returns the actual value or '' if not set
5180 // while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set
5181 var fixedContent = [].slice.call(document.querySelectorAll(Selector$5.FIXED_CONTENT));
5182 var stickyContent = [].slice.call(document.querySelectorAll(Selector$5.STICKY_CONTENT)); // Adjust fixed content padding
5183
5184 $(fixedContent).each(function (index, element) {
5185 var actualPadding = element.style.paddingRight;
5186 var calculatedPadding = $(element).css('padding-right');
5187 $(element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this10._scrollbarWidth + "px");
5188 }); // Adjust sticky content margin
5189
5190 $(stickyContent).each(function (index, element) {
5191 var actualMargin = element.style.marginRight;
5192 var calculatedMargin = $(element).css('margin-right');
5193 $(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this10._scrollbarWidth + "px");
5194 }); // Adjust body padding
5195
5196 var actualPadding = document.body.style.paddingRight;
5197 var calculatedPadding = $(document.body).css('padding-right');
5198 $(document.body).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px");
5199 }
5200
5201 $(document.body).addClass(ClassName$5.OPEN);
5202 };
5203
5204 _proto._resetScrollbar = function _resetScrollbar() {
5205 // Restore fixed content padding
5206 var fixedContent = [].slice.call(document.querySelectorAll(Selector$5.FIXED_CONTENT));
5207 $(fixedContent).each(function (index, element) {
5208 var padding = $(element).data('padding-right');
5209 $(element).removeData('padding-right');
5210 element.style.paddingRight = padding ? padding : '';
5211 }); // Restore sticky content
5212
5213 var elements = [].slice.call(document.querySelectorAll("" + Selector$5.STICKY_CONTENT));
5214 $(elements).each(function (index, element) {
5215 var margin = $(element).data('margin-right');
5216
5217 if (typeof margin !== 'undefined') {
5218 $(element).css('margin-right', margin).removeData('margin-right');
5219 }
5220 }); // Restore body padding
5221
5222 var padding = $(document.body).data('padding-right');
5223 $(document.body).removeData('padding-right');
5224 document.body.style.paddingRight = padding ? padding : '';
5225 };
5226
5227 _proto._getScrollbarWidth = function _getScrollbarWidth() {
5228 // thx d.walsh
5229 var scrollDiv = document.createElement('div');
5230 scrollDiv.className = ClassName$5.SCROLLBAR_MEASURER;
5231 document.body.appendChild(scrollDiv);
5232 var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
5233 document.body.removeChild(scrollDiv);
5234 return scrollbarWidth;
5235 } // Static
5236 ;
5237
5238 Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) {
5239 return this.each(function () {
5240 var data = $(this).data(DATA_KEY$5);
5241
5242 var _config = _objectSpread2({}, Default$3, {}, $(this).data(), {}, typeof config === 'object' && config ? config : {});
5243
5244 if (!data) {
5245 data = new Modal(this, _config);
5246 $(this).data(DATA_KEY$5, data);
5247 }
5248
5249 if (typeof config === 'string') {
5250 if (typeof data[config] === 'undefined') {
5251 throw new TypeError("No method named \"" + config + "\"");
5252 }
5253
5254 data[config](relatedTarget);
5255 } else if (_config.show) {
5256 data.show(relatedTarget);
5257 }
5258 });
5259 };
5260
5261 _createClass(Modal, null, [{
5262 key: "VERSION",
5263 get: function get() {
5264 return VERSION$5;
5265 }
5266 }, {
5267 key: "Default",
5268 get: function get() {
5269 return Default$3;
5270 }
5271 }]);
5272
5273 return Modal;
5274 }();
5275 /**
5276 * ------------------------------------------------------------------------
5277 * Data Api implementation
5278 * ------------------------------------------------------------------------
5279 */
5280
5281
5282 $(document).on(Event$5.CLICK_DATA_API, Selector$5.DATA_TOGGLE, function (event) {
5283 var _this11 = this;
5284
5285 var target;
5286 var selector = Util.getSelectorFromElement(this);
5287
5288 if (selector) {
5289 target = document.querySelector(selector);
5290 }
5291
5292 var config = $(target).data(DATA_KEY$5) ? 'toggle' : _objectSpread2({}, $(target).data(), {}, $(this).data());
5293
5294 if (this.tagName === 'A' || this.tagName === 'AREA') {
5295 event.preventDefault();
5296 }
5297
5298 var $target = $(target).one(Event$5.SHOW, function (showEvent) {
5299 if (showEvent.isDefaultPrevented()) {
5300 // Only register focus restorer if modal will actually get shown
5301 return;
5302 }
5303
5304 $target.one(Event$5.HIDDEN, function () {
5305 if ($(_this11).is(':visible')) {
5306 _this11.focus();
5307 }
5308 });
5309 });
5310
5311 Modal._jQueryInterface.call($(target), config, this);
5312 });
5313 /**
5314 * ------------------------------------------------------------------------
5315 * jQuery
5316 * ------------------------------------------------------------------------
5317 */
5318
5319 $.fn[NAME$5] = Modal._jQueryInterface;
5320 $.fn[NAME$5].Constructor = Modal;
5321
5322 $.fn[NAME$5].noConflict = function () {
5323 $.fn[NAME$5] = JQUERY_NO_CONFLICT$5;
5324 return Modal._jQueryInterface;
5325 };
5326
5327 /**
5328 * --------------------------------------------------------------------------
5329 * Bootstrap (v4.4.1): tools/sanitizer.js
5330 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
5331 * --------------------------------------------------------------------------
5332 */
5333 var uriAttrs = ['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href'];
5334 var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
5335 var DefaultWhitelist = {
5336 // Global attributes allowed on any supplied element below.
5337 '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
5338 a: ['target', 'href', 'title', 'rel'],
5339 area: [],
5340 b: [],
5341 br: [],
5342 col: [],
5343 code: [],
5344 div: [],
5345 em: [],
5346 hr: [],
5347 h1: [],
5348 h2: [],
5349 h3: [],
5350 h4: [],
5351 h5: [],
5352 h6: [],
5353 i: [],
5354 img: ['src', 'alt', 'title', 'width', 'height'],
5355 li: [],
5356 ol: [],
5357 p: [],
5358 pre: [],
5359 s: [],
5360 small: [],
5361 span: [],
5362 sub: [],
5363 sup: [],
5364 strong: [],
5365 u: [],
5366 ul: []
5367 };
5368 /**
5369 * A pattern that recognizes a commonly useful subset of URLs that are safe.
5370 *
5371 * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
5372 */
5373
5374 var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi;
5375 /**
5376 * A pattern that matches safe data URLs. Only matches image, video and audio types.
5377 *
5378 * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
5379 */
5380
5381 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;
5382
5383 function allowedAttribute(attr, allowedAttributeList) {
5384 var attrName = attr.nodeName.toLowerCase();
5385
5386 if (allowedAttributeList.indexOf(attrName) !== -1) {
5387 if (uriAttrs.indexOf(attrName) !== -1) {
5388 return Boolean(attr.nodeValue.match(SAFE_URL_PATTERN) || attr.nodeValue.match(DATA_URL_PATTERN));
5389 }
5390
5391 return true;
5392 }
5393
5394 var regExp = allowedAttributeList.filter(function (attrRegex) {
5395 return attrRegex instanceof RegExp;
5396 }); // Check if a regular expression validates the attribute.
5397
5398 for (var i = 0, l = regExp.length; i < l; i++) {
5399 if (attrName.match(regExp[i])) {
5400 return true;
5401 }
5402 }
5403
5404 return false;
5405 }
5406
5407 function sanitizeHtml(unsafeHtml, whiteList, sanitizeFn) {
5408 if (unsafeHtml.length === 0) {
5409 return unsafeHtml;
5410 }
5411
5412 if (sanitizeFn && typeof sanitizeFn === 'function') {
5413 return sanitizeFn(unsafeHtml);
5414 }
5415
5416 var domParser = new window.DOMParser();
5417 var createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');
5418 var whitelistKeys = Object.keys(whiteList);
5419 var elements = [].slice.call(createdDocument.body.querySelectorAll('*'));
5420
5421 var _loop = function _loop(i, len) {
5422 var el = elements[i];
5423 var elName = el.nodeName.toLowerCase();
5424
5425 if (whitelistKeys.indexOf(el.nodeName.toLowerCase()) === -1) {
5426 el.parentNode.removeChild(el);
5427 return "continue";
5428 }
5429
5430 var attributeList = [].slice.call(el.attributes);
5431 var whitelistedAttributes = [].concat(whiteList['*'] || [], whiteList[elName] || []);
5432 attributeList.forEach(function (attr) {
5433 if (!allowedAttribute(attr, whitelistedAttributes)) {
5434 el.removeAttribute(attr.nodeName);
5435 }
5436 });
5437 };
5438
5439 for (var i = 0, len = elements.length; i < len; i++) {
5440 var _ret = _loop(i);
5441
5442 if (_ret === "continue") continue;
5443 }
5444
5445 return createdDocument.body.innerHTML;
5446 }
5447
5448 /**
5449 * ------------------------------------------------------------------------
5450 * Constants
5451 * ------------------------------------------------------------------------
5452 */
5453
5454 var NAME$6 = 'tooltip';
5455 var VERSION$6 = '4.4.1';
5456 var DATA_KEY$6 = 'bs.tooltip';
5457 var EVENT_KEY$6 = "." + DATA_KEY$6;
5458 var JQUERY_NO_CONFLICT$6 = $.fn[NAME$6];
5459 var CLASS_PREFIX = 'bs-tooltip';
5460 var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g');
5461 var DISALLOWED_ATTRIBUTES = ['sanitize', 'whiteList', 'sanitizeFn'];
5462 var DefaultType$4 = {
5463 animation: 'boolean',
5464 template: 'string',
5465 title: '(string|element|function)',
5466 trigger: 'string',
5467 delay: '(number|object)',
5468 html: 'boolean',
5469 selector: '(string|boolean)',
5470 placement: '(string|function)',
5471 offset: '(number|string|function)',
5472 container: '(string|element|boolean)',
5473 fallbackPlacement: '(string|array)',
5474 boundary: '(string|element)',
5475 sanitize: 'boolean',
5476 sanitizeFn: '(null|function)',
5477 whiteList: 'object',
5478 popperConfig: '(null|object)'
5479 };
5480 var AttachmentMap$1 = {
5481 AUTO: 'auto',
5482 TOP: 'top',
5483 RIGHT: 'right',
5484 BOTTOM: 'bottom',
5485 LEFT: 'left'
5486 };
5487 var Default$4 = {
5488 animation: true,
5489 template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>',
5490 trigger: 'hover focus',
5491 title: '',
5492 delay: 0,
5493 html: false,
5494 selector: false,
5495 placement: 'top',
5496 offset: 0,
5497 container: false,
5498 fallbackPlacement: 'flip',
5499 boundary: 'scrollParent',
5500 sanitize: true,
5501 sanitizeFn: null,
5502 whiteList: DefaultWhitelist,
5503 popperConfig: null
5504 };
5505 var HoverState = {
5506 SHOW: 'show',
5507 OUT: 'out'
5508 };
5509 var Event$6 = {
5510 HIDE: "hide" + EVENT_KEY$6,
5511 HIDDEN: "hidden" + EVENT_KEY$6,
5512 SHOW: "show" + EVENT_KEY$6,
5513 SHOWN: "shown" + EVENT_KEY$6,
5514 INSERTED: "inserted" + EVENT_KEY$6,
5515 CLICK: "click" + EVENT_KEY$6,
5516 FOCUSIN: "focusin" + EVENT_KEY$6,
5517 FOCUSOUT: "focusout" + EVENT_KEY$6,
5518 MOUSEENTER: "mouseenter" + EVENT_KEY$6,
5519 MOUSELEAVE: "mouseleave" + EVENT_KEY$6
5520 };
5521 var ClassName$6 = {
5522 FADE: 'fade',
5523 SHOW: 'show'
5524 };
5525 var Selector$6 = {
5526 TOOLTIP: '.tooltip',
5527 TOOLTIP_INNER: '.tooltip-inner',
5528 ARROW: '.arrow'
5529 };
5530 var Trigger = {
5531 HOVER: 'hover',
5532 FOCUS: 'focus',
5533 CLICK: 'click',
5534 MANUAL: 'manual'
5535 };
5536 /**
5537 * ------------------------------------------------------------------------
5538 * Class Definition
5539 * ------------------------------------------------------------------------
5540 */
5541
5542 var Tooltip =
5543 /*#__PURE__*/
5544 function () {
5545 function Tooltip(element, config) {
5546 if (typeof Popper === 'undefined') {
5547 throw new TypeError('Bootstrap\'s tooltips require Popper.js (https://popper.js.org/)');
5548 } // private
5549
5550
5551 this._isEnabled = true;
5552 this._timeout = 0;
5553 this._hoverState = '';
5554 this._activeTrigger = {};
5555 this._popper = null; // Protected
5556
5557 this.element = element;
5558 this.config = this._getConfig(config);
5559 this.tip = null;
5560
5561 this._setListeners();
5562 } // Getters
5563
5564
5565 var _proto = Tooltip.prototype;
5566
5567 // Public
5568 _proto.enable = function enable() {
5569 this._isEnabled = true;
5570 };
5571
5572 _proto.disable = function disable() {
5573 this._isEnabled = false;
5574 };
5575
5576 _proto.toggleEnabled = function toggleEnabled() {
5577 this._isEnabled = !this._isEnabled;
5578 };
5579
5580 _proto.toggle = function toggle(event) {
5581 if (!this._isEnabled) {
5582 return;
5583 }
5584
5585 if (event) {
5586 var dataKey = this.constructor.DATA_KEY;
5587 var context = $(event.currentTarget).data(dataKey);
5588
5589 if (!context) {
5590 context = new this.constructor(event.currentTarget, this._getDelegateConfig());
5591 $(event.currentTarget).data(dataKey, context);
5592 }
5593
5594 context._activeTrigger.click = !context._activeTrigger.click;
5595
5596 if (context._isWithActiveTrigger()) {
5597 context._enter(null, context);
5598 } else {
5599 context._leave(null, context);
5600 }
5601 } else {
5602 if ($(this.getTipElement()).hasClass(ClassName$6.SHOW)) {
5603 this._leave(null, this);
5604
5605 return;
5606 }
5607
5608 this._enter(null, this);
5609 }
5610 };
5611
5612 _proto.dispose = function dispose() {
5613 clearTimeout(this._timeout);
5614 $.removeData(this.element, this.constructor.DATA_KEY);
5615 $(this.element).off(this.constructor.EVENT_KEY);
5616 $(this.element).closest('.modal').off('hide.bs.modal', this._hideModalHandler);
5617
5618 if (this.tip) {
5619 $(this.tip).remove();
5620 }
5621
5622 this._isEnabled = null;
5623 this._timeout = null;
5624 this._hoverState = null;
5625 this._activeTrigger = null;
5626
5627 if (this._popper) {
5628 this._popper.destroy();
5629 }
5630
5631 this._popper = null;
5632 this.element = null;
5633 this.config = null;
5634 this.tip = null;
5635 };
5636
5637 _proto.show = function show() {
5638 var _this = this;
5639
5640 if ($(this.element).css('display') === 'none') {
5641 throw new Error('Please use show on visible elements');
5642 }
5643
5644 var showEvent = $.Event(this.constructor.Event.SHOW);
5645
5646 if (this.isWithContent() && this._isEnabled) {
5647 $(this.element).trigger(showEvent);
5648 var shadowRoot = Util.findShadowRoot(this.element);
5649 var isInTheDom = $.contains(shadowRoot !== null ? shadowRoot : this.element.ownerDocument.documentElement, this.element);
5650
5651 if (showEvent.isDefaultPrevented() || !isInTheDom) {
5652 return;
5653 }
5654
5655 var tip = this.getTipElement();
5656 var tipId = Util.getUID(this.constructor.NAME);
5657 tip.setAttribute('id', tipId);
5658 this.element.setAttribute('aria-describedby', tipId);
5659 this.setContent();
5660
5661 if (this.config.animation) {
5662 $(tip).addClass(ClassName$6.FADE);
5663 }
5664
5665 var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement;
5666
5667 var attachment = this._getAttachment(placement);
5668
5669 this.addAttachmentClass(attachment);
5670
5671 var container = this._getContainer();
5672
5673 $(tip).data(this.constructor.DATA_KEY, this);
5674
5675 if (!$.contains(this.element.ownerDocument.documentElement, this.tip)) {
5676 $(tip).appendTo(container);
5677 }
5678
5679 $(this.element).trigger(this.constructor.Event.INSERTED);
5680 this._popper = new Popper(this.element, tip, this._getPopperConfig(attachment));
5681 $(tip).addClass(ClassName$6.SHOW); // If this is a touch-enabled device we add extra
5682 // empty mouseover listeners to the body's immediate children;
5683 // only needed because of broken event delegation on iOS
5684 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
5685
5686 if ('ontouchstart' in document.documentElement) {
5687 $(document.body).children().on('mouseover', null, $.noop);
5688 }
5689
5690 var complete = function complete() {
5691 if (_this.config.animation) {
5692 _this._fixTransition();
5693 }
5694
5695 var prevHoverState = _this._hoverState;
5696 _this._hoverState = null;
5697 $(_this.element).trigger(_this.constructor.Event.SHOWN);
5698
5699 if (prevHoverState === HoverState.OUT) {
5700 _this._leave(null, _this);
5701 }
5702 };
5703
5704 if ($(this.tip).hasClass(ClassName$6.FADE)) {
5705 var transitionDuration = Util.getTransitionDurationFromElement(this.tip);
5706 $(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
5707 } else {
5708 complete();
5709 }
5710 }
5711 };
5712
5713 _proto.hide = function hide(callback) {
5714 var _this2 = this;
5715
5716 var tip = this.getTipElement();
5717 var hideEvent = $.Event(this.constructor.Event.HIDE);
5718
5719 var complete = function complete() {
5720 if (_this2._hoverState !== HoverState.SHOW && tip.parentNode) {
5721 tip.parentNode.removeChild(tip);
5722 }
5723
5724 _this2._cleanTipClass();
5725
5726 _this2.element.removeAttribute('aria-describedby');
5727
5728 $(_this2.element).trigger(_this2.constructor.Event.HIDDEN);
5729
5730 if (_this2._popper !== null) {
5731 _this2._popper.destroy();
5732 }
5733
5734 if (callback) {
5735 callback();
5736 }
5737 };
5738
5739 $(this.element).trigger(hideEvent);
5740
5741 if (hideEvent.isDefaultPrevented()) {
5742 return;
5743 }
5744
5745 $(tip).removeClass(ClassName$6.SHOW); // If this is a touch-enabled device we remove the extra
5746 // empty mouseover listeners we added for iOS support
5747
5748 if ('ontouchstart' in document.documentElement) {
5749 $(document.body).children().off('mouseover', null, $.noop);
5750 }
5751
5752 this._activeTrigger[Trigger.CLICK] = false;
5753 this._activeTrigger[Trigger.FOCUS] = false;
5754 this._activeTrigger[Trigger.HOVER] = false;
5755
5756 if ($(this.tip).hasClass(ClassName$6.FADE)) {
5757 var transitionDuration = Util.getTransitionDurationFromElement(tip);
5758 $(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
5759 } else {
5760 complete();
5761 }
5762
5763 this._hoverState = '';
5764 };
5765
5766 _proto.update = function update() {
5767 if (this._popper !== null) {
5768 this._popper.scheduleUpdate();
5769 }
5770 } // Protected
5771 ;
5772
5773 _proto.isWithContent = function isWithContent() {
5774 return Boolean(this.getTitle());
5775 };
5776
5777 _proto.addAttachmentClass = function addAttachmentClass(attachment) {
5778 $(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment);
5779 };
5780
5781 _proto.getTipElement = function getTipElement() {
5782 this.tip = this.tip || $(this.config.template)[0];
5783 return this.tip;
5784 };
5785
5786 _proto.setContent = function setContent() {
5787 var tip = this.getTipElement();
5788 this.setElementContent($(tip.querySelectorAll(Selector$6.TOOLTIP_INNER)), this.getTitle());
5789 $(tip).removeClass(ClassName$6.FADE + " " + ClassName$6.SHOW);
5790 };
5791
5792 _proto.setElementContent = function setElementContent($element, content) {
5793 if (typeof content === 'object' && (content.nodeType || content.jquery)) {
5794 // Content is a DOM node or a jQuery
5795 if (this.config.html) {
5796 if (!$(content).parent().is($element)) {
5797 $element.empty().append(content);
5798 }
5799 } else {
5800 $element.text($(content).text());
5801 }
5802
5803 return;
5804 }
5805
5806 if (this.config.html) {
5807 if (this.config.sanitize) {
5808 content = sanitizeHtml(content, this.config.whiteList, this.config.sanitizeFn);
5809 }
5810
5811 $element.html(content);
5812 } else {
5813 $element.text(content);
5814 }
5815 };
5816
5817 _proto.getTitle = function getTitle() {
5818 var title = this.element.getAttribute('data-original-title');
5819
5820 if (!title) {
5821 title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title;
5822 }
5823
5824 return title;
5825 } // Private
5826 ;
5827
5828 _proto._getPopperConfig = function _getPopperConfig(attachment) {
5829 var _this3 = this;
5830
5831 var defaultBsConfig = {
5832 placement: attachment,
5833 modifiers: {
5834 offset: this._getOffset(),
5835 flip: {
5836 behavior: this.config.fallbackPlacement
5837 },
5838 arrow: {
5839 element: Selector$6.ARROW
5840 },
5841 preventOverflow: {
5842 boundariesElement: this.config.boundary
5843 }
5844 },
5845 onCreate: function onCreate(data) {
5846 if (data.originalPlacement !== data.placement) {
5847 _this3._handlePopperPlacementChange(data);
5848 }
5849 },
5850 onUpdate: function onUpdate(data) {
5851 return _this3._handlePopperPlacementChange(data);
5852 }
5853 };
5854 return _objectSpread2({}, defaultBsConfig, {}, this.config.popperConfig);
5855 };
5856
5857 _proto._getOffset = function _getOffset() {
5858 var _this4 = this;
5859
5860 var offset = {};
5861
5862 if (typeof this.config.offset === 'function') {
5863 offset.fn = function (data) {
5864 data.offsets = _objectSpread2({}, data.offsets, {}, _this4.config.offset(data.offsets, _this4.element) || {});
5865 return data;
5866 };
5867 } else {
5868 offset.offset = this.config.offset;
5869 }
5870
5871 return offset;
5872 };
5873
5874 _proto._getContainer = function _getContainer() {
5875 if (this.config.container === false) {
5876 return document.body;
5877 }
5878
5879 if (Util.isElement(this.config.container)) {
5880 return $(this.config.container);
5881 }
5882
5883 return $(document).find(this.config.container);
5884 };
5885
5886 _proto._getAttachment = function _getAttachment(placement) {
5887 return AttachmentMap$1[placement.toUpperCase()];
5888 };
5889
5890 _proto._setListeners = function _setListeners() {
5891 var _this5 = this;
5892
5893 var triggers = this.config.trigger.split(' ');
5894 triggers.forEach(function (trigger) {
5895 if (trigger === 'click') {
5896 $(_this5.element).on(_this5.constructor.Event.CLICK, _this5.config.selector, function (event) {
5897 return _this5.toggle(event);
5898 });
5899 } else if (trigger !== Trigger.MANUAL) {
5900 var eventIn = trigger === Trigger.HOVER ? _this5.constructor.Event.MOUSEENTER : _this5.constructor.Event.FOCUSIN;
5901 var eventOut = trigger === Trigger.HOVER ? _this5.constructor.Event.MOUSELEAVE : _this5.constructor.Event.FOCUSOUT;
5902 $(_this5.element).on(eventIn, _this5.config.selector, function (event) {
5903 return _this5._enter(event);
5904 }).on(eventOut, _this5.config.selector, function (event) {
5905 return _this5._leave(event);
5906 });
5907 }
5908 });
5909
5910 this._hideModalHandler = function () {
5911 if (_this5.element) {
5912 _this5.hide();
5913 }
5914 };
5915
5916 $(this.element).closest('.modal').on('hide.bs.modal', this._hideModalHandler);
5917
5918 if (this.config.selector) {
5919 this.config = _objectSpread2({}, this.config, {
5920 trigger: 'manual',
5921 selector: ''
5922 });
5923 } else {
5924 this._fixTitle();
5925 }
5926 };
5927
5928 _proto._fixTitle = function _fixTitle() {
5929 var titleType = typeof this.element.getAttribute('data-original-title');
5930
5931 if (this.element.getAttribute('title') || titleType !== 'string') {
5932 this.element.setAttribute('data-original-title', this.element.getAttribute('title') || '');
5933 this.element.setAttribute('title', '');
5934 }
5935 };
5936
5937 _proto._enter = function _enter(event, context) {
5938 var dataKey = this.constructor.DATA_KEY;
5939 context = context || $(event.currentTarget).data(dataKey);
5940
5941 if (!context) {
5942 context = new this.constructor(event.currentTarget, this._getDelegateConfig());
5943 $(event.currentTarget).data(dataKey, context);
5944 }
5945
5946 if (event) {
5947 context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true;
5948 }
5949
5950 if ($(context.getTipElement()).hasClass(ClassName$6.SHOW) || context._hoverState === HoverState.SHOW) {
5951 context._hoverState = HoverState.SHOW;
5952 return;
5953 }
5954
5955 clearTimeout(context._timeout);
5956 context._hoverState = HoverState.SHOW;
5957
5958 if (!context.config.delay || !context.config.delay.show) {
5959 context.show();
5960 return;
5961 }
5962
5963 context._timeout = setTimeout(function () {
5964 if (context._hoverState === HoverState.SHOW) {
5965 context.show();
5966 }
5967 }, context.config.delay.show);
5968 };
5969
5970 _proto._leave = function _leave(event, context) {
5971 var dataKey = this.constructor.DATA_KEY;
5972 context = context || $(event.currentTarget).data(dataKey);
5973
5974 if (!context) {
5975 context = new this.constructor(event.currentTarget, this._getDelegateConfig());
5976 $(event.currentTarget).data(dataKey, context);
5977 }
5978
5979 if (event) {
5980 context._activeTrigger[event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER] = false;
5981 }
5982
5983 if (context._isWithActiveTrigger()) {
5984 return;
5985 }
5986
5987 clearTimeout(context._timeout);
5988 context._hoverState = HoverState.OUT;
5989
5990 if (!context.config.delay || !context.config.delay.hide) {
5991 context.hide();
5992 return;
5993 }
5994
5995 context._timeout = setTimeout(function () {
5996 if (context._hoverState === HoverState.OUT) {
5997 context.hide();
5998 }
5999 }, context.config.delay.hide);
6000 };
6001
6002 _proto._isWithActiveTrigger = function _isWithActiveTrigger() {
6003 for (var trigger in this._activeTrigger) {
6004 if (this._activeTrigger[trigger]) {
6005 return true;
6006 }
6007 }
6008
6009 return false;
6010 };
6011
6012 _proto._getConfig = function _getConfig(config) {
6013 var dataAttributes = $(this.element).data();
6014 Object.keys(dataAttributes).forEach(function (dataAttr) {
6015 if (DISALLOWED_ATTRIBUTES.indexOf(dataAttr) !== -1) {
6016 delete dataAttributes[dataAttr];
6017 }
6018 });
6019 config = _objectSpread2({}, this.constructor.Default, {}, dataAttributes, {}, typeof config === 'object' && config ? config : {});
6020
6021 if (typeof config.delay === 'number') {
6022 config.delay = {
6023 show: config.delay,
6024 hide: config.delay
6025 };
6026 }
6027
6028 if (typeof config.title === 'number') {
6029 config.title = config.title.toString();
6030 }
6031
6032 if (typeof config.content === 'number') {
6033 config.content = config.content.toString();
6034 }
6035
6036 Util.typeCheckConfig(NAME$6, config, this.constructor.DefaultType);
6037
6038 if (config.sanitize) {
6039 config.template = sanitizeHtml(config.template, config.whiteList, config.sanitizeFn);
6040 }
6041
6042 return config;
6043 };
6044
6045 _proto._getDelegateConfig = function _getDelegateConfig() {
6046 var config = {};
6047
6048 if (this.config) {
6049 for (var key in this.config) {
6050 if (this.constructor.Default[key] !== this.config[key]) {
6051 config[key] = this.config[key];
6052 }
6053 }
6054 }
6055
6056 return config;
6057 };
6058
6059 _proto._cleanTipClass = function _cleanTipClass() {
6060 var $tip = $(this.getTipElement());
6061 var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX);
6062
6063 if (tabClass !== null && tabClass.length) {
6064 $tip.removeClass(tabClass.join(''));
6065 }
6066 };
6067
6068 _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) {
6069 var popperInstance = popperData.instance;
6070 this.tip = popperInstance.popper;
6071
6072 this._cleanTipClass();
6073
6074 this.addAttachmentClass(this._getAttachment(popperData.placement));
6075 };
6076
6077 _proto._fixTransition = function _fixTransition() {
6078 var tip = this.getTipElement();
6079 var initConfigAnimation = this.config.animation;
6080
6081 if (tip.getAttribute('x-placement') !== null) {
6082 return;
6083 }
6084
6085 $(tip).removeClass(ClassName$6.FADE);
6086 this.config.animation = false;
6087 this.hide();
6088 this.show();
6089 this.config.animation = initConfigAnimation;
6090 } // Static
6091 ;
6092
6093 Tooltip._jQueryInterface = function _jQueryInterface(config) {
6094 return this.each(function () {
6095 var data = $(this).data(DATA_KEY$6);
6096
6097 var _config = typeof config === 'object' && config;
6098
6099 if (!data && /dispose|hide/.test(config)) {
6100 return;
6101 }
6102
6103 if (!data) {
6104 data = new Tooltip(this, _config);
6105 $(this).data(DATA_KEY$6, data);
6106 }
6107
6108 if (typeof config === 'string') {
6109 if (typeof data[config] === 'undefined') {
6110 throw new TypeError("No method named \"" + config + "\"");
6111 }
6112
6113 data[config]();
6114 }
6115 });
6116 };
6117
6118 _createClass(Tooltip, null, [{
6119 key: "VERSION",
6120 get: function get() {
6121 return VERSION$6;
6122 }
6123 }, {
6124 key: "Default",
6125 get: function get() {
6126 return Default$4;
6127 }
6128 }, {
6129 key: "NAME",
6130 get: function get() {
6131 return NAME$6;
6132 }
6133 }, {
6134 key: "DATA_KEY",
6135 get: function get() {
6136 return DATA_KEY$6;
6137 }
6138 }, {
6139 key: "Event",
6140 get: function get() {
6141 return Event$6;
6142 }
6143 }, {
6144 key: "EVENT_KEY",
6145 get: function get() {
6146 return EVENT_KEY$6;
6147 }
6148 }, {
6149 key: "DefaultType",
6150 get: function get() {
6151 return DefaultType$4;
6152 }
6153 }]);
6154
6155 return Tooltip;
6156 }();
6157 /**
6158 * ------------------------------------------------------------------------
6159 * jQuery
6160 * ------------------------------------------------------------------------
6161 */
6162
6163
6164 $.fn[NAME$6] = Tooltip._jQueryInterface;
6165 $.fn[NAME$6].Constructor = Tooltip;
6166
6167 $.fn[NAME$6].noConflict = function () {
6168 $.fn[NAME$6] = JQUERY_NO_CONFLICT$6;
6169 return Tooltip._jQueryInterface;
6170 };
6171
6172 /**
6173 * ------------------------------------------------------------------------
6174 * Constants
6175 * ------------------------------------------------------------------------
6176 */
6177
6178 var NAME$7 = 'popover';
6179 var VERSION$7 = '4.4.1';
6180 var DATA_KEY$7 = 'bs.popover';
6181 var EVENT_KEY$7 = "." + DATA_KEY$7;
6182 var JQUERY_NO_CONFLICT$7 = $.fn[NAME$7];
6183 var CLASS_PREFIX$1 = 'bs-popover';
6184 var BSCLS_PREFIX_REGEX$1 = new RegExp("(^|\\s)" + CLASS_PREFIX$1 + "\\S+", 'g');
6185
6186 var Default$5 = _objectSpread2({}, Tooltip.Default, {
6187 placement: 'right',
6188 trigger: 'click',
6189 content: '',
6190 template: '<div class="popover" role="tooltip">' + '<div class="arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div></div>'
6191 });
6192
6193 var DefaultType$5 = _objectSpread2({}, Tooltip.DefaultType, {
6194 content: '(string|element|function)'
6195 });
6196
6197 var ClassName$7 = {
6198 FADE: 'fade',
6199 SHOW: 'show'
6200 };
6201 var Selector$7 = {
6202 TITLE: '.popover-header',
6203 CONTENT: '.popover-body'
6204 };
6205 var Event$7 = {
6206 HIDE: "hide" + EVENT_KEY$7,
6207 HIDDEN: "hidden" + EVENT_KEY$7,
6208 SHOW: "show" + EVENT_KEY$7,
6209 SHOWN: "shown" + EVENT_KEY$7,
6210 INSERTED: "inserted" + EVENT_KEY$7,
6211 CLICK: "click" + EVENT_KEY$7,
6212 FOCUSIN: "focusin" + EVENT_KEY$7,
6213 FOCUSOUT: "focusout" + EVENT_KEY$7,
6214 MOUSEENTER: "mouseenter" + EVENT_KEY$7,
6215 MOUSELEAVE: "mouseleave" + EVENT_KEY$7
6216 };
6217 /**
6218 * ------------------------------------------------------------------------
6219 * Class Definition
6220 * ------------------------------------------------------------------------
6221 */
6222
6223 var Popover =
6224 /*#__PURE__*/
6225 function (_Tooltip) {
6226 _inheritsLoose(Popover, _Tooltip);
6227
6228 function Popover() {
6229 return _Tooltip.apply(this, arguments) || this;
6230 }
6231
6232 var _proto = Popover.prototype;
6233
6234 // Overrides
6235 _proto.isWithContent = function isWithContent() {
6236 return this.getTitle() || this._getContent();
6237 };
6238
6239 _proto.addAttachmentClass = function addAttachmentClass(attachment) {
6240 $(this.getTipElement()).addClass(CLASS_PREFIX$1 + "-" + attachment);
6241 };
6242
6243 _proto.getTipElement = function getTipElement() {
6244 this.tip = this.tip || $(this.config.template)[0];
6245 return this.tip;
6246 };
6247
6248 _proto.setContent = function setContent() {
6249 var $tip = $(this.getTipElement()); // We use append for html objects to maintain js events
6250
6251 this.setElementContent($tip.find(Selector$7.TITLE), this.getTitle());
6252
6253 var content = this._getContent();
6254
6255 if (typeof content === 'function') {
6256 content = content.call(this.element);
6257 }
6258
6259 this.setElementContent($tip.find(Selector$7.CONTENT), content);
6260 $tip.removeClass(ClassName$7.FADE + " " + ClassName$7.SHOW);
6261 } // Private
6262 ;
6263
6264 _proto._getContent = function _getContent() {
6265 return this.element.getAttribute('data-content') || this.config.content;
6266 };
6267
6268 _proto._cleanTipClass = function _cleanTipClass() {
6269 var $tip = $(this.getTipElement());
6270 var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX$1);
6271
6272 if (tabClass !== null && tabClass.length > 0) {
6273 $tip.removeClass(tabClass.join(''));
6274 }
6275 } // Static
6276 ;
6277
6278 Popover._jQueryInterface = function _jQueryInterface(config) {
6279 return this.each(function () {
6280 var data = $(this).data(DATA_KEY$7);
6281
6282 var _config = typeof config === 'object' ? config : null;
6283
6284 if (!data && /dispose|hide/.test(config)) {
6285 return;
6286 }
6287
6288 if (!data) {
6289 data = new Popover(this, _config);
6290 $(this).data(DATA_KEY$7, data);
6291 }
6292
6293 if (typeof config === 'string') {
6294 if (typeof data[config] === 'undefined') {
6295 throw new TypeError("No method named \"" + config + "\"");
6296 }
6297
6298 data[config]();
6299 }
6300 });
6301 };
6302
6303 _createClass(Popover, null, [{
6304 key: "VERSION",
6305 // Getters
6306 get: function get() {
6307 return VERSION$7;
6308 }
6309 }, {
6310 key: "Default",
6311 get: function get() {
6312 return Default$5;
6313 }
6314 }, {
6315 key: "NAME",
6316 get: function get() {
6317 return NAME$7;
6318 }
6319 }, {
6320 key: "DATA_KEY",
6321 get: function get() {
6322 return DATA_KEY$7;
6323 }
6324 }, {
6325 key: "Event",
6326 get: function get() {
6327 return Event$7;
6328 }
6329 }, {
6330 key: "EVENT_KEY",
6331 get: function get() {
6332 return EVENT_KEY$7;
6333 }
6334 }, {
6335 key: "DefaultType",
6336 get: function get() {
6337 return DefaultType$5;
6338 }
6339 }]);
6340
6341 return Popover;
6342 }(Tooltip);
6343 /**
6344 * ------------------------------------------------------------------------
6345 * jQuery
6346 * ------------------------------------------------------------------------
6347 */
6348
6349
6350 $.fn[NAME$7] = Popover._jQueryInterface;
6351 $.fn[NAME$7].Constructor = Popover;
6352
6353 $.fn[NAME$7].noConflict = function () {
6354 $.fn[NAME$7] = JQUERY_NO_CONFLICT$7;
6355 return Popover._jQueryInterface;
6356 };
6357
6358 /**
6359 * ------------------------------------------------------------------------
6360 * Constants
6361 * ------------------------------------------------------------------------
6362 */
6363
6364 var NAME$8 = 'scrollspy';
6365 var VERSION$8 = '4.4.1';
6366 var DATA_KEY$8 = 'bs.scrollspy';
6367 var EVENT_KEY$8 = "." + DATA_KEY$8;
6368 var DATA_API_KEY$6 = '.data-api';
6369 var JQUERY_NO_CONFLICT$8 = $.fn[NAME$8];
6370 var Default$6 = {
6371 offset: 10,
6372 method: 'auto',
6373 target: ''
6374 };
6375 var DefaultType$6 = {
6376 offset: 'number',
6377 method: 'string',
6378 target: '(string|element)'
6379 };
6380 var Event$8 = {
6381 ACTIVATE: "activate" + EVENT_KEY$8,
6382 SCROLL: "scroll" + EVENT_KEY$8,
6383 LOAD_DATA_API: "load" + EVENT_KEY$8 + DATA_API_KEY$6
6384 };
6385 var ClassName$8 = {
6386 DROPDOWN_ITEM: 'dropdown-item',
6387 DROPDOWN_MENU: 'dropdown-menu',
6388 ACTIVE: 'active'
6389 };
6390 var Selector$8 = {
6391 DATA_SPY: '[data-spy="scroll"]',
6392 ACTIVE: '.active',
6393 NAV_LIST_GROUP: '.nav, .list-group',
6394 NAV_LINKS: '.nav-link',
6395 NAV_ITEMS: '.nav-item',
6396 LIST_ITEMS: '.list-group-item',
6397 DROPDOWN: '.dropdown',
6398 DROPDOWN_ITEMS: '.dropdown-item',
6399 DROPDOWN_TOGGLE: '.dropdown-toggle'
6400 };
6401 var OffsetMethod = {
6402 OFFSET: 'offset',
6403 POSITION: 'position'
6404 };
6405 /**
6406 * ------------------------------------------------------------------------
6407 * Class Definition
6408 * ------------------------------------------------------------------------
6409 */
6410
6411 var ScrollSpy =
6412 /*#__PURE__*/
6413 function () {
6414 function ScrollSpy(element, config) {
6415 var _this = this;
6416
6417 this._element = element;
6418 this._scrollElement = element.tagName === 'BODY' ? window : element;
6419 this._config = this._getConfig(config);
6420 this._selector = this._config.target + " " + Selector$8.NAV_LINKS + "," + (this._config.target + " " + Selector$8.LIST_ITEMS + ",") + (this._config.target + " " + Selector$8.DROPDOWN_ITEMS);
6421 this._offsets = [];
6422 this._targets = [];
6423 this._activeTarget = null;
6424 this._scrollHeight = 0;
6425 $(this._scrollElement).on(Event$8.SCROLL, function (event) {
6426 return _this._process(event);
6427 });
6428 this.refresh();
6429
6430 this._process();
6431 } // Getters
6432
6433
6434 var _proto = ScrollSpy.prototype;
6435
6436 // Public
6437 _proto.refresh = function refresh() {
6438 var _this2 = this;
6439
6440 var autoMethod = this._scrollElement === this._scrollElement.window ? OffsetMethod.OFFSET : OffsetMethod.POSITION;
6441 var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
6442 var offsetBase = offsetMethod === OffsetMethod.POSITION ? this._getScrollTop() : 0;
6443 this._offsets = [];
6444 this._targets = [];
6445 this._scrollHeight = this._getScrollHeight();
6446 var targets = [].slice.call(document.querySelectorAll(this._selector));
6447 targets.map(function (element) {
6448 var target;
6449 var targetSelector = Util.getSelectorFromElement(element);
6450
6451 if (targetSelector) {
6452 target = document.querySelector(targetSelector);
6453 }
6454
6455 if (target) {
6456 var targetBCR = target.getBoundingClientRect();
6457
6458 if (targetBCR.width || targetBCR.height) {
6459 // TODO (fat): remove sketch reliance on jQuery position/offset
6460 return [$(target)[offsetMethod]().top + offsetBase, targetSelector];
6461 }
6462 }
6463
6464 return null;
6465 }).filter(function (item) {
6466 return item;
6467 }).sort(function (a, b) {
6468 return a[0] - b[0];
6469 }).forEach(function (item) {
6470 _this2._offsets.push(item[0]);
6471
6472 _this2._targets.push(item[1]);
6473 });
6474 };
6475
6476 _proto.dispose = function dispose() {
6477 $.removeData(this._element, DATA_KEY$8);
6478 $(this._scrollElement).off(EVENT_KEY$8);
6479 this._element = null;
6480 this._scrollElement = null;
6481 this._config = null;
6482 this._selector = null;
6483 this._offsets = null;
6484 this._targets = null;
6485 this._activeTarget = null;
6486 this._scrollHeight = null;
6487 } // Private
6488 ;
6489
6490 _proto._getConfig = function _getConfig(config) {
6491 config = _objectSpread2({}, Default$6, {}, typeof config === 'object' && config ? config : {});
6492
6493 if (typeof config.target !== 'string') {
6494 var id = $(config.target).attr('id');
6495
6496 if (!id) {
6497 id = Util.getUID(NAME$8);
6498 $(config.target).attr('id', id);
6499 }
6500
6501 config.target = "#" + id;
6502 }
6503
6504 Util.typeCheckConfig(NAME$8, config, DefaultType$6);
6505 return config;
6506 };
6507
6508 _proto._getScrollTop = function _getScrollTop() {
6509 return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
6510 };
6511
6512 _proto._getScrollHeight = function _getScrollHeight() {
6513 return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
6514 };
6515
6516 _proto._getOffsetHeight = function _getOffsetHeight() {
6517 return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
6518 };
6519
6520 _proto._process = function _process() {
6521 var scrollTop = this._getScrollTop() + this._config.offset;
6522
6523 var scrollHeight = this._getScrollHeight();
6524
6525 var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
6526
6527 if (this._scrollHeight !== scrollHeight) {
6528 this.refresh();
6529 }
6530
6531 if (scrollTop >= maxScroll) {
6532 var target = this._targets[this._targets.length - 1];
6533
6534 if (this._activeTarget !== target) {
6535 this._activate(target);
6536 }
6537
6538 return;
6539 }
6540
6541 if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
6542 this._activeTarget = null;
6543
6544 this._clear();
6545
6546 return;
6547 }
6548
6549 var offsetLength = this._offsets.length;
6550
6551 for (var i = offsetLength; i--;) {
6552 var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
6553
6554 if (isActiveTarget) {
6555 this._activate(this._targets[i]);
6556 }
6557 }
6558 };
6559
6560 _proto._activate = function _activate(target) {
6561 this._activeTarget = target;
6562
6563 this._clear();
6564
6565 var queries = this._selector.split(',').map(function (selector) {
6566 return selector + "[data-target=\"" + target + "\"]," + selector + "[href=\"" + target + "\"]";
6567 });
6568
6569 var $link = $([].slice.call(document.querySelectorAll(queries.join(','))));
6570
6571 if ($link.hasClass(ClassName$8.DROPDOWN_ITEM)) {
6572 $link.closest(Selector$8.DROPDOWN).find(Selector$8.DROPDOWN_TOGGLE).addClass(ClassName$8.ACTIVE);
6573 $link.addClass(ClassName$8.ACTIVE);
6574 } else {
6575 // Set triggered link as active
6576 $link.addClass(ClassName$8.ACTIVE); // Set triggered links parents as active
6577 // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
6578
6579 $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
6580
6581 $link.parents(Selector$8.NAV_LIST_GROUP).prev(Selector$8.NAV_ITEMS).children(Selector$8.NAV_LINKS).addClass(ClassName$8.ACTIVE);
6582 }
6583
6584 $(this._scrollElement).trigger(Event$8.ACTIVATE, {
6585 relatedTarget: target
6586 });
6587 };
6588
6589 _proto._clear = function _clear() {
6590 [].slice.call(document.querySelectorAll(this._selector)).filter(function (node) {
6591 return node.classList.contains(ClassName$8.ACTIVE);
6592 }).forEach(function (node) {
6593 return node.classList.remove(ClassName$8.ACTIVE);
6594 });
6595 } // Static
6596 ;
6597
6598 ScrollSpy._jQueryInterface = function _jQueryInterface(config) {
6599 return this.each(function () {
6600 var data = $(this).data(DATA_KEY$8);
6601
6602 var _config = typeof config === 'object' && config;
6603
6604 if (!data) {
6605 data = new ScrollSpy(this, _config);
6606 $(this).data(DATA_KEY$8, data);
6607 }
6608
6609 if (typeof config === 'string') {
6610 if (typeof data[config] === 'undefined') {
6611 throw new TypeError("No method named \"" + config + "\"");
6612 }
6613
6614 data[config]();
6615 }
6616 });
6617 };
6618
6619 _createClass(ScrollSpy, null, [{
6620 key: "VERSION",
6621 get: function get() {
6622 return VERSION$8;
6623 }
6624 }, {
6625 key: "Default",
6626 get: function get() {
6627 return Default$6;
6628 }
6629 }]);
6630
6631 return ScrollSpy;
6632 }();
6633 /**
6634 * ------------------------------------------------------------------------
6635 * Data Api implementation
6636 * ------------------------------------------------------------------------
6637 */
6638
6639
6640 $(window).on(Event$8.LOAD_DATA_API, function () {
6641 var scrollSpys = [].slice.call(document.querySelectorAll(Selector$8.DATA_SPY));
6642 var scrollSpysLength = scrollSpys.length;
6643
6644 for (var i = scrollSpysLength; i--;) {
6645 var $spy = $(scrollSpys[i]);
6646
6647 ScrollSpy._jQueryInterface.call($spy, $spy.data());
6648 }
6649 });
6650 /**
6651 * ------------------------------------------------------------------------
6652 * jQuery
6653 * ------------------------------------------------------------------------
6654 */
6655
6656 $.fn[NAME$8] = ScrollSpy._jQueryInterface;
6657 $.fn[NAME$8].Constructor = ScrollSpy;
6658
6659 $.fn[NAME$8].noConflict = function () {
6660 $.fn[NAME$8] = JQUERY_NO_CONFLICT$8;
6661 return ScrollSpy._jQueryInterface;
6662 };
6663
6664 /**
6665 * ------------------------------------------------------------------------
6666 * Constants
6667 * ------------------------------------------------------------------------
6668 */
6669
6670 var NAME$9 = 'tab';
6671 var VERSION$9 = '4.4.1';
6672 var DATA_KEY$9 = 'bs.tab';
6673 var EVENT_KEY$9 = "." + DATA_KEY$9;
6674 var DATA_API_KEY$7 = '.data-api';
6675 var JQUERY_NO_CONFLICT$9 = $.fn[NAME$9];
6676 var Event$9 = {
6677 HIDE: "hide" + EVENT_KEY$9,
6678 HIDDEN: "hidden" + EVENT_KEY$9,
6679 SHOW: "show" + EVENT_KEY$9,
6680 SHOWN: "shown" + EVENT_KEY$9,
6681 CLICK_DATA_API: "click" + EVENT_KEY$9 + DATA_API_KEY$7
6682 };
6683 var ClassName$9 = {
6684 DROPDOWN_MENU: 'dropdown-menu',
6685 ACTIVE: 'active',
6686 DISABLED: 'disabled',
6687 FADE: 'fade',
6688 SHOW: 'show'
6689 };
6690 var Selector$9 = {
6691 DROPDOWN: '.dropdown',
6692 NAV_LIST_GROUP: '.nav, .list-group',
6693 ACTIVE: '.active',
6694 ACTIVE_UL: '> li > .active',
6695 DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]',
6696 DROPDOWN_TOGGLE: '.dropdown-toggle',
6697 DROPDOWN_ACTIVE_CHILD: '> .dropdown-menu .active'
6698 };
6699 /**
6700 * ------------------------------------------------------------------------
6701 * Class Definition
6702 * ------------------------------------------------------------------------
6703 */
6704
6705 var Tab =
6706 /*#__PURE__*/
6707 function () {
6708 function Tab(element) {
6709 this._element = element;
6710 } // Getters
6711
6712
6713 var _proto = Tab.prototype;
6714
6715 // Public
6716 _proto.show = function show() {
6717 var _this = this;
6718
6719 if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $(this._element).hasClass(ClassName$9.ACTIVE) || $(this._element).hasClass(ClassName$9.DISABLED)) {
6720 return;
6721 }
6722
6723 var target;
6724 var previous;
6725 var listElement = $(this._element).closest(Selector$9.NAV_LIST_GROUP)[0];
6726 var selector = Util.getSelectorFromElement(this._element);
6727
6728 if (listElement) {
6729 var itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? Selector$9.ACTIVE_UL : Selector$9.ACTIVE;
6730 previous = $.makeArray($(listElement).find(itemSelector));
6731 previous = previous[previous.length - 1];
6732 }
6733
6734 var hideEvent = $.Event(Event$9.HIDE, {
6735 relatedTarget: this._element
6736 });
6737 var showEvent = $.Event(Event$9.SHOW, {
6738 relatedTarget: previous
6739 });
6740
6741 if (previous) {
6742 $(previous).trigger(hideEvent);
6743 }
6744
6745 $(this._element).trigger(showEvent);
6746
6747 if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) {
6748 return;
6749 }
6750
6751 if (selector) {
6752 target = document.querySelector(selector);
6753 }
6754
6755 this._activate(this._element, listElement);
6756
6757 var complete = function complete() {
6758 var hiddenEvent = $.Event(Event$9.HIDDEN, {
6759 relatedTarget: _this._element
6760 });
6761 var shownEvent = $.Event(Event$9.SHOWN, {
6762 relatedTarget: previous
6763 });
6764 $(previous).trigger(hiddenEvent);
6765 $(_this._element).trigger(shownEvent);
6766 };
6767
6768 if (target) {
6769 this._activate(target, target.parentNode, complete);
6770 } else {
6771 complete();
6772 }
6773 };
6774
6775 _proto.dispose = function dispose() {
6776 $.removeData(this._element, DATA_KEY$9);
6777 this._element = null;
6778 } // Private
6779 ;
6780
6781 _proto._activate = function _activate(element, container, callback) {
6782 var _this2 = this;
6783
6784 var activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? $(container).find(Selector$9.ACTIVE_UL) : $(container).children(Selector$9.ACTIVE);
6785 var active = activeElements[0];
6786 var isTransitioning = callback && active && $(active).hasClass(ClassName$9.FADE);
6787
6788 var complete = function complete() {
6789 return _this2._transitionComplete(element, active, callback);
6790 };
6791
6792 if (active && isTransitioning) {
6793 var transitionDuration = Util.getTransitionDurationFromElement(active);
6794 $(active).removeClass(ClassName$9.SHOW).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
6795 } else {
6796 complete();
6797 }
6798 };
6799
6800 _proto._transitionComplete = function _transitionComplete(element, active, callback) {
6801 if (active) {
6802 $(active).removeClass(ClassName$9.ACTIVE);
6803 var dropdownChild = $(active.parentNode).find(Selector$9.DROPDOWN_ACTIVE_CHILD)[0];
6804
6805 if (dropdownChild) {
6806 $(dropdownChild).removeClass(ClassName$9.ACTIVE);
6807 }
6808
6809 if (active.getAttribute('role') === 'tab') {
6810 active.setAttribute('aria-selected', false);
6811 }
6812 }
6813
6814 $(element).addClass(ClassName$9.ACTIVE);
6815
6816 if (element.getAttribute('role') === 'tab') {
6817 element.setAttribute('aria-selected', true);
6818 }
6819
6820 Util.reflow(element);
6821
6822 if (element.classList.contains(ClassName$9.FADE)) {
6823 element.classList.add(ClassName$9.SHOW);
6824 }
6825
6826 if (element.parentNode && $(element.parentNode).hasClass(ClassName$9.DROPDOWN_MENU)) {
6827 var dropdownElement = $(element).closest(Selector$9.DROPDOWN)[0];
6828
6829 if (dropdownElement) {
6830 var dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(Selector$9.DROPDOWN_TOGGLE));
6831 $(dropdownToggleList).addClass(ClassName$9.ACTIVE);
6832 }
6833
6834 element.setAttribute('aria-expanded', true);
6835 }
6836
6837 if (callback) {
6838 callback();
6839 }
6840 } // Static
6841 ;
6842
6843 Tab._jQueryInterface = function _jQueryInterface(config) {
6844 return this.each(function () {
6845 var $this = $(this);
6846 var data = $this.data(DATA_KEY$9);
6847
6848 if (!data) {
6849 data = new Tab(this);
6850 $this.data(DATA_KEY$9, data);
6851 }
6852
6853 if (typeof config === 'string') {
6854 if (typeof data[config] === 'undefined') {
6855 throw new TypeError("No method named \"" + config + "\"");
6856 }
6857
6858 data[config]();
6859 }
6860 });
6861 };
6862
6863 _createClass(Tab, null, [{
6864 key: "VERSION",
6865 get: function get() {
6866 return VERSION$9;
6867 }
6868 }]);
6869
6870 return Tab;
6871 }();
6872 /**
6873 * ------------------------------------------------------------------------
6874 * Data Api implementation
6875 * ------------------------------------------------------------------------
6876 */
6877
6878
6879 $(document).on(Event$9.CLICK_DATA_API, Selector$9.DATA_TOGGLE, function (event) {
6880 event.preventDefault();
6881
6882 Tab._jQueryInterface.call($(this), 'show');
6883 });
6884 /**
6885 * ------------------------------------------------------------------------
6886 * jQuery
6887 * ------------------------------------------------------------------------
6888 */
6889
6890 $.fn[NAME$9] = Tab._jQueryInterface;
6891 $.fn[NAME$9].Constructor = Tab;
6892
6893 $.fn[NAME$9].noConflict = function () {
6894 $.fn[NAME$9] = JQUERY_NO_CONFLICT$9;
6895 return Tab._jQueryInterface;
6896 };
6897
6898 /**
6899 * ------------------------------------------------------------------------
6900 * Constants
6901 * ------------------------------------------------------------------------
6902 */
6903
6904 var NAME$a = 'toast';
6905 var VERSION$a = '4.4.1';
6906 var DATA_KEY$a = 'bs.toast';
6907 var EVENT_KEY$a = "." + DATA_KEY$a;
6908 var JQUERY_NO_CONFLICT$a = $.fn[NAME$a];
6909 var Event$a = {
6910 CLICK_DISMISS: "click.dismiss" + EVENT_KEY$a,
6911 HIDE: "hide" + EVENT_KEY$a,
6912 HIDDEN: "hidden" + EVENT_KEY$a,
6913 SHOW: "show" + EVENT_KEY$a,
6914 SHOWN: "shown" + EVENT_KEY$a
6915 };
6916 var ClassName$a = {
6917 FADE: 'fade',
6918 HIDE: 'hide',
6919 SHOW: 'show',
6920 SHOWING: 'showing'
6921 };
6922 var DefaultType$7 = {
6923 animation: 'boolean',
6924 autohide: 'boolean',
6925 delay: 'number'
6926 };
6927 var Default$7 = {
6928 animation: true,
6929 autohide: true,
6930 delay: 500
6931 };
6932 var Selector$a = {
6933 DATA_DISMISS: '[data-dismiss="toast"]'
6934 };
6935 /**
6936 * ------------------------------------------------------------------------
6937 * Class Definition
6938 * ------------------------------------------------------------------------
6939 */
6940
6941 var Toast =
6942 /*#__PURE__*/
6943 function () {
6944 function Toast(element, config) {
6945 this._element = element;
6946 this._config = this._getConfig(config);
6947 this._timeout = null;
6948
6949 this._setListeners();
6950 } // Getters
6951
6952
6953 var _proto = Toast.prototype;
6954
6955 // Public
6956 _proto.show = function show() {
6957 var _this = this;
6958
6959 var showEvent = $.Event(Event$a.SHOW);
6960 $(this._element).trigger(showEvent);
6961
6962 if (showEvent.isDefaultPrevented()) {
6963 return;
6964 }
6965
6966 if (this._config.animation) {
6967 this._element.classList.add(ClassName$a.FADE);
6968 }
6969
6970 var complete = function complete() {
6971 _this._element.classList.remove(ClassName$a.SHOWING);
6972
6973 _this._element.classList.add(ClassName$a.SHOW);
6974
6975 $(_this._element).trigger(Event$a.SHOWN);
6976
6977 if (_this._config.autohide) {
6978 _this._timeout = setTimeout(function () {
6979 _this.hide();
6980 }, _this._config.delay);
6981 }
6982 };
6983
6984 this._element.classList.remove(ClassName$a.HIDE);
6985
6986 Util.reflow(this._element);
6987
6988 this._element.classList.add(ClassName$a.SHOWING);
6989
6990 if (this._config.animation) {
6991 var transitionDuration = Util.getTransitionDurationFromElement(this._element);
6992 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
6993 } else {
6994 complete();
6995 }
6996 };
6997
6998 _proto.hide = function hide() {
6999 if (!this._element.classList.contains(ClassName$a.SHOW)) {
7000 return;
7001 }
7002
7003 var hideEvent = $.Event(Event$a.HIDE);
7004 $(this._element).trigger(hideEvent);
7005
7006 if (hideEvent.isDefaultPrevented()) {
7007 return;
7008 }
7009
7010 this._close();
7011 };
7012
7013 _proto.dispose = function dispose() {
7014 clearTimeout(this._timeout);
7015 this._timeout = null;
7016
7017 if (this._element.classList.contains(ClassName$a.SHOW)) {
7018 this._element.classList.remove(ClassName$a.SHOW);
7019 }
7020
7021 $(this._element).off(Event$a.CLICK_DISMISS);
7022 $.removeData(this._element, DATA_KEY$a);
7023 this._element = null;
7024 this._config = null;
7025 } // Private
7026 ;
7027
7028 _proto._getConfig = function _getConfig(config) {
7029 config = _objectSpread2({}, Default$7, {}, $(this._element).data(), {}, typeof config === 'object' && config ? config : {});
7030 Util.typeCheckConfig(NAME$a, config, this.constructor.DefaultType);
7031 return config;
7032 };
7033
7034 _proto._setListeners = function _setListeners() {
7035 var _this2 = this;
7036
7037 $(this._element).on(Event$a.CLICK_DISMISS, Selector$a.DATA_DISMISS, function () {
7038 return _this2.hide();
7039 });
7040 };
7041
7042 _proto._close = function _close() {
7043 var _this3 = this;
7044
7045 var complete = function complete() {
7046 _this3._element.classList.add(ClassName$a.HIDE);
7047
7048 $(_this3._element).trigger(Event$a.HIDDEN);
7049 };
7050
7051 this._element.classList.remove(ClassName$a.SHOW);
7052
7053 if (this._config.animation) {
7054 var transitionDuration = Util.getTransitionDurationFromElement(this._element);
7055 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
7056 } else {
7057 complete();
7058 }
7059 } // Static
7060 ;
7061
7062 Toast._jQueryInterface = function _jQueryInterface(config) {
7063 return this.each(function () {
7064 var $element = $(this);
7065 var data = $element.data(DATA_KEY$a);
7066
7067 var _config = typeof config === 'object' && config;
7068
7069 if (!data) {
7070 data = new Toast(this, _config);
7071 $element.data(DATA_KEY$a, data);
7072 }
7073
7074 if (typeof config === 'string') {
7075 if (typeof data[config] === 'undefined') {
7076 throw new TypeError("No method named \"" + config + "\"");
7077 }
7078
7079 data[config](this);
7080 }
7081 });
7082 };
7083
7084 _createClass(Toast, null, [{
7085 key: "VERSION",
7086 get: function get() {
7087 return VERSION$a;
7088 }
7089 }, {
7090 key: "DefaultType",
7091 get: function get() {
7092 return DefaultType$7;
7093 }
7094 }, {
7095 key: "Default",
7096 get: function get() {
7097 return Default$7;
7098 }
7099 }]);
7100
7101 return Toast;
7102 }();
7103 /**
7104 * ------------------------------------------------------------------------
7105 * jQuery
7106 * ------------------------------------------------------------------------
7107 */
7108
7109
7110 $.fn[NAME$a] = Toast._jQueryInterface;
7111 $.fn[NAME$a].Constructor = Toast;
7112
7113 $.fn[NAME$a].noConflict = function () {
7114 $.fn[NAME$a] = JQUERY_NO_CONFLICT$a;
7115 return Toast._jQueryInterface;
7116 };
7117
7118 exports.Alert = Alert;
7119 exports.Button = Button;
7120 exports.Carousel = Carousel;
7121 exports.Collapse = Collapse;
7122 exports.Dropdown = Dropdown;
7123 exports.Modal = Modal;
7124 exports.Popover = Popover;
7125 exports.Scrollspy = ScrollSpy;
7126 exports.Tab = Tab;
7127 exports.Toast = Toast;
7128 exports.Tooltip = Tooltip;
7129 exports.Util = Util;
7130
7131 Object.defineProperty(exports, '__esModule', { value: true });
7132
7133})));
7134//# sourceMappingURL=bootstrap.bundle.js.map
Note: See TracBrowser for help on using the repository browser.