UsersWP – Front-end login form, User Registration, User Profile & Members Directory plugin for WP / 1.2.66

UsersWP – Front-end login form, User Registration, User Profile & Members Directory plugin for WP v1.2.66

userswp / vendor / ayecode / wp-ayecode-ui / assets / js / bootstrap.js

bootstrap.js in UsersWP – Front-end login form, User Registration, User Profile & Members Directory plugin for WP 1.2.66, at vendor/ayecode/wp-ayecode-ui/assets/js/bootstrap.js

4,357 lines 134.5 KB

Raw Download Zip

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