WebSVN - Integrator Subversion - Blame - Rev 760 - /projeto-trade/stocklifepro/src/main/webapp/resources/poseidon-layout/js-extra/bootstrap.js

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

Subversion Repositories Integrator Subversion

(root)/projeto-trade/stocklifepro/src/main/webapp/resources/poseidon-layout/js-extra/bootstrap.js - Rev 760