Diffusion Flamenco Manager (master) Browse

bootstrap.bundle.js
b6f6d5dd2e9fmaster

bootstrap.bundle.js
View Options

			/*!
			* Bootstrap v4.3.1 (https://getbootstrap.com/)
			* Copyright 2011-2019 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
			* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
			*/
			(function (global, factory) {
			typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery')) :
			typeof define === 'function' && define.amd ? define(['exports', 'jquery'], factory) :
			(global = global \|\| self, factory(global.bootstrap = {}, global.jQuery));
			}(this, function (exports, $) { 'use strict';

			$ = $ && $.hasOwnProperty('default') ? $['default'] : $;

			function _defineProperties(target, props) {
			for (var i = 0; i < props.length; i++) {
			var descriptor = props[i];
			descriptor.enumerable = descriptor.enumerable \|\| false;
			descriptor.configurable = true;
			if ("value" in descriptor) descriptor.writable = true;
			Object.defineProperty(target, descriptor.key, descriptor);
			}
			}

			function _createClass(Constructor, protoProps, staticProps) {
			if (protoProps) _defineProperties(Constructor.prototype, protoProps);
			if (staticProps) _defineProperties(Constructor, staticProps);
			return Constructor;
			}

			function _defineProperty(obj, key, value) {
			if (key in obj) {
			Object.defineProperty(obj, key, {
			value: value,
			enumerable: true,
			configurable: true,
			writable: true
			});
			} else {
			obj[key] = value;
			}

			return obj;
			}

			function _objectSpread(target) {
			for (var i = 1; i < arguments.length; i++) {
			var source = arguments[i] != null ? arguments[i] : {};
			var ownKeys = Object.keys(source);

			if (typeof Object.getOwnPropertySymbols === 'function') {
			ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
			return Object.getOwnPropertyDescriptor(source, sym).enumerable;
			}));
			}

			ownKeys.forEach(function (key) {
			_defineProperty(target, key, source[key]);
			});
			}

			return target;
			}

			function _inheritsLoose(subClass, superClass) {
			subClass.prototype = Object.create(superClass.prototype);
			subClass.prototype.constructor = subClass;
			subClass.__proto__ = superClass;
			}

			/**
			* --------------------------------------------------------------------------
			* Bootstrap (v4.3.1): util.js
			* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
			* --------------------------------------------------------------------------
			*/
			/**
			* ------------------------------------------------------------------------
			* Private TransitionEnd Helpers
			* ------------------------------------------------------------------------
			*/

			var TRANSITION_END = 'transitionend';
			var MAX_UID = 1000000;
			var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp)

			function toType(obj) {
			return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
			}

			function getSpecialTransitionEndEvent() {
			return {
			bindType: TRANSITION_END,
			delegateType: TRANSITION_END,
			handle: function handle(event) {
			if ($(event.target).is(this)) {
			return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params
			}

			return undefined; // eslint-disable-line no-undefined
			}
			};
			}

			function transitionEndEmulator(duration) {
			var _this = this;

			var called = false;
			$(this).one(Util.TRANSITION_END, function () {
			called = true;
			});
			setTimeout(function () {
			if (!called) {
			Util.triggerTransitionEnd(_this);
			}
			}, duration);
			return this;
			}

			function setTransitionEndSupport() {
			$.fn.emulateTransitionEnd = transitionEndEmulator;
			$.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
			}
			/**
			* --------------------------------------------------------------------------
			* Public Util Api
			* --------------------------------------------------------------------------
			*/


			var Util = {
			TRANSITION_END: 'bsTransitionEnd',
			getUID: function getUID(prefix) {
			do {
			// eslint-disable-next-line no-bitwise
			prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here
			} while (document.getElementById(prefix));

			return prefix;
			},
			getSelectorFromElement: function getSelectorFromElement(element) {
			var selector = element.getAttribute('data-target');

			if (!selector \|\| selector === '#') {
			var hrefAttr = element.getAttribute('href');
			selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : '';
			}

			try {
			return document.querySelector(selector) ? selector : null;
			} catch (err) {
			return null;
			}
			},
			getTransitionDurationFromElement: function getTransitionDurationFromElement(element) {
			if (!element) {
			return 0;
			} // Get transition-duration of the element


			var transitionDuration = $(element).css('transition-duration');
			var transitionDelay = $(element).css('transition-delay');
			var floatTransitionDuration = parseFloat(transitionDuration);
			var floatTransitionDelay = parseFloat(transitionDelay); // Return 0 if element or transition duration is not found

			if (!floatTransitionDuration && !floatTransitionDelay) {
			return 0;
			} // If multiple durations are defined, take the first


			transitionDuration = transitionDuration.split(',')[0];
			transitionDelay = transitionDelay.split(',')[0];
			return (parseFloat(transitionDuration) + parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
			},
			reflow: function reflow(element) {
			return element.offsetHeight;
			},
			triggerTransitionEnd: function triggerTransitionEnd(element) {
			$(element).trigger(TRANSITION_END);
			},
			// TODO: Remove in v5
			supportsTransitionEnd: function supportsTransitionEnd() {
			return Boolean(TRANSITION_END);
			},
			isElement: function isElement(obj) {
			return (obj[0] \|\| obj).nodeType;
			},
			typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) {
			for (var property in configTypes) {
			if (Object.prototype.hasOwnProperty.call(configTypes, property)) {
			var expectedTypes = configTypes[property];
			var value = config[property];
			var valueType = value && Util.isElement(value) ? 'element' : toType(value);

			if (!new RegExp(expectedTypes).test(valueType)) {
			throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\"."));
			}
			}
			}
			},
			findShadowRoot: function findShadowRoot(element) {
			if (!document.documentElement.attachShadow) {
			return null;
			} // Can find the shadow root otherwise it'll return the document


			if (typeof element.getRootNode === 'function') {
			var root = element.getRootNode();
			return root instanceof ShadowRoot ? root : null;
			}

			if (element instanceof ShadowRoot) {
			return element;
			} // when we don't find a shadow root


			if (!element.parentNode) {
			return null;
			}

			return Util.findShadowRoot(element.parentNode);
			}
			};
			setTransitionEndSupport();

			/**
			* ------------------------------------------------------------------------
			* Constants
			* ------------------------------------------------------------------------
			*/

			var NAME = 'alert';
			var VERSION = '4.3.1';
			var DATA_KEY = 'bs.alert';
			var EVENT_KEY = "." + DATA_KEY;
			var DATA_API_KEY = '.data-api';
			var JQUERY_NO_CONFLICT = $.fn[NAME];
			var Selector = {
			DISMISS: '[data-dismiss="alert"]'
			};
			var Event = {
			CLOSE: "close" + EVENT_KEY,
			CLOSED: "closed" + EVENT_KEY,
			CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
			};
			var ClassName = {
			ALERT: 'alert',
			FADE: 'fade',
			SHOW: 'show'
			/**
			* ------------------------------------------------------------------------
			* Class Definition
			* ------------------------------------------------------------------------
			*/

			};

			var Alert =
			/#__PURE__/
			function () {
			function Alert(element) {
			this._element = element;
			} // Getters


			var _proto = Alert.prototype;

			// Public
			_proto.close = function close(element) {
			var rootElement = this._element;

			if (element) {
			rootElement = this._getRootElement(element);
			}

			var customEvent = this._triggerCloseEvent(rootElement);

			if (customEvent.isDefaultPrevented()) {
			return;
			}

			this._removeElement(rootElement);
			};

			_proto.dispose = function dispose() {
			$.removeData(this._element, DATA_KEY);
			this._element = null;
			} // Private
			;

			_proto._getRootElement = function _getRootElement(element) {
			var selector = Util.getSelectorFromElement(element);
			var parent = false;

			if (selector) {
			parent = document.querySelector(selector);
			}

			if (!parent) {
			parent = $(element).closest("." + ClassName.ALERT)[0];
			}

			return parent;
			};

			_proto._triggerCloseEvent = function _triggerCloseEvent(element) {
			var closeEvent = $.Event(Event.CLOSE);
			$(element).trigger(closeEvent);
			return closeEvent;
			};

			_proto._removeElement = function _removeElement(element) {
			var _this = this;

			$(element).removeClass(ClassName.SHOW);

			if (!$(element).hasClass(ClassName.FADE)) {
			this._destroyElement(element);

			return;
			}

			var transitionDuration = Util.getTransitionDurationFromElement(element);
			$(element).one(Util.TRANSITION_END, function (event) {
			return _this._destroyElement(element, event);
			}).emulateTransitionEnd(transitionDuration);
			};

			_proto._destroyElement = function _destroyElement(element) {
			$(element).detach().trigger(Event.CLOSED).remove();
			} // Static
			;

			Alert._jQueryInterface = function _jQueryInterface(config) {
			return this.each(function () {
			var $element = $(this);
			var data = $element.data(DATA_KEY);

			if (!data) {
			data = new Alert(this);
			$element.data(DATA_KEY, data);
			}

			if (config === 'close') {
			data[config](this);
			}
			});
			};

			Alert._handleDismiss = function _handleDismiss(alertInstance) {
			return function (event) {
			if (event) {
			event.preventDefault();
			}

			alertInstance.close(this);
			};
			};

			_createClass(Alert, null, [{
			key: "VERSION",
			get: function get() {
			return VERSION;
			}
			}]);

			return Alert;
			}();
			/**
			* ------------------------------------------------------------------------
			* Data Api implementation
			* ------------------------------------------------------------------------
			*/


			$(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert()));
			/**
			* ------------------------------------------------------------------------
			* jQuery
			* ------------------------------------------------------------------------
			*/

			$.fn[NAME] = Alert._jQueryInterface;
			$.fn[NAME].Constructor = Alert;

			$.fn[NAME].noConflict = function () {
			$.fn[NAME] = JQUERY_NO_CONFLICT;
			return Alert._jQueryInterface;
			};

			/**
			* ------------------------------------------------------------------------
			* Constants
			* ------------------------------------------------------------------------
			*/

			var NAME$1 = 'button';
			var VERSION$1 = '4.3.1';
			var DATA_KEY$1 = 'bs.button';
			var EVENT_KEY$1 = "." + DATA_KEY$1;
			var DATA_API_KEY$1 = '.data-api';
			var JQUERY_NO_CONFLICT$1 = $.fn[NAME$1];
			var ClassName$1 = {
			ACTIVE: 'active',
			BUTTON: 'btn',
			FOCUS: 'focus'
			};
			var Selector$1 = {
			DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
			DATA_TOGGLE: '[data-toggle="buttons"]',
			INPUT: 'input:not([type="hidden"])',
			ACTIVE: '.active',
			BUTTON: '.btn'
			};
			var Event$1 = {
			CLICK_DATA_API: "click" + EVENT_KEY$1 + DATA_API_KEY$1,
			FOCUS_BLUR_DATA_API: "focus" + EVENT_KEY$1 + DATA_API_KEY$1 + " " + ("blur" + EVENT_KEY$1 + DATA_API_KEY$1)
			/**
			* ------------------------------------------------------------------------
			* Class Definition
			* ------------------------------------------------------------------------
			*/

			};

			var Button =
			/#__PURE__/
			function () {
			function Button(element) {
			this._element = element;
			} // Getters


			var _proto = Button.prototype;

			// Public
			_proto.toggle = function toggle() {
			var triggerChangeEvent = true;
			var addAriaPressed = true;
			var rootElement = $(this._element).closest(Selector$1.DATA_TOGGLE)[0];

			if (rootElement) {
			var input = this._element.querySelector(Selector$1.INPUT);

			if (input) {
			if (input.type === 'radio') {
			if (input.checked && this._element.classList.contains(ClassName$1.ACTIVE)) {
			triggerChangeEvent = false;
			} else {
			var activeElement = rootElement.querySelector(Selector$1.ACTIVE);

			if (activeElement) {
			$(activeElement).removeClass(ClassName$1.ACTIVE);
			}
			}
			}

			if (triggerChangeEvent) {
			if (input.hasAttribute('disabled') \|\| rootElement.hasAttribute('disabled') \|\| input.classList.contains('disabled') \|\| rootElement.classList.contains('disabled')) {
			return;
			}

			input.checked = !this._element.classList.contains(ClassName$1.ACTIVE);
			$(input).trigger('change');
			}

			input.focus();
			addAriaPressed = false;
			}
			}

			if (addAriaPressed) {
			this._element.setAttribute('aria-pressed', !this._element.classList.contains(ClassName$1.ACTIVE));
			}

			if (triggerChangeEvent) {
			$(this._element).toggleClass(ClassName$1.ACTIVE);
			}
			};

			_proto.dispose = function dispose() {
			$.removeData(this._element, DATA_KEY$1);
			this._element = null;
			} // Static
			;

			Button._jQueryInterface = function _jQueryInterface(config) {
			return this.each(function () {
			var data = $(this).data(DATA_KEY$1);

			if (!data) {
			data = new Button(this);
			$(this).data(DATA_KEY$1, data);
			}

			if (config === 'toggle') {
			data[config]();
			}
			});
			};

			_createClass(Button, null, [{
			key: "VERSION",
			get: function get() {
			return VERSION$1;
			}
			}]);

			return Button;
			}();
			/**
			* ------------------------------------------------------------------------
			* Data Api implementation
			* ------------------------------------------------------------------------
			*/


			$(document).on(Event$1.CLICK_DATA_API, Selector$1.DATA_TOGGLE_CARROT, function (event) {
			event.preventDefault();
			var button = event.target;

			if (!$(button).hasClass(ClassName$1.BUTTON)) {
			button = $(button).closest(Selector$1.BUTTON);
			}

			Button._jQueryInterface.call($(button), 'toggle');
			}).on(Event$1.FOCUS_BLUR_DATA_API, Selector$1.DATA_TOGGLE_CARROT, function (event) {
			var button = $(event.target).closest(Selector$1.BUTTON)[0];
			$(button).toggleClass(ClassName$1.FOCUS, /^focus(in)?$/.test(event.type));
			});
			/**
			* ------------------------------------------------------------------------
			* jQuery
			* ------------------------------------------------------------------------
			*/

			$.fn[NAME$1] = Button._jQueryInterface;
			$.fn[NAME$1].Constructor = Button;

			$.fn[NAME$1].noConflict = function () {
			$.fn[NAME$1] = JQUERY_NO_CONFLICT$1;
			return Button._jQueryInterface;
			};

			/**
			* ------------------------------------------------------------------------
			* Constants
			* ------------------------------------------------------------------------
			*/

			var NAME$2 = 'carousel';
			var VERSION$2 = '4.3.1';
			var DATA_KEY$2 = 'bs.carousel';
			var EVENT_KEY$2 = "." + DATA_KEY$2;
			var DATA_API_KEY$2 = '.data-api';
			var JQUERY_NO_CONFLICT$2 = $.fn[NAME$2];
			var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key

			var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key

			var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch

			var SWIPE_THRESHOLD = 40;
			var Default = {
			interval: 5000,
			keyboard: true,
			slide: false,
			pause: 'hover',
			wrap: true,
			touch: true
			};
			var DefaultType = {
			interval: '(number\|boolean)',
			keyboard: 'boolean',
			slide: '(boolean\|string)',
			pause: '(string\|boolean)',
			wrap: 'boolean',
			touch: 'boolean'
			};
			var Direction = {
			NEXT: 'next',
			PREV: 'prev',
			LEFT: 'left',
			RIGHT: 'right'
			};
			var Event$2 = {
			SLIDE: "slide" + EVENT_KEY$2,
			SLID: "slid" + EVENT_KEY$2,
			KEYDOWN: "keydown" + EVENT_KEY$2,
			MOUSEENTER: "mouseenter" + EVENT_KEY$2,
			MOUSELEAVE: "mouseleave" + EVENT_KEY$2,
			TOUCHSTART: "touchstart" + EVENT_KEY$2,
			TOUCHMOVE: "touchmove" + EVENT_KEY$2,
			TOUCHEND: "touchend" + EVENT_KEY$2,
			POINTERDOWN: "pointerdown" + EVENT_KEY$2,
			POINTERUP: "pointerup" + EVENT_KEY$2,
			DRAG_START: "dragstart" + EVENT_KEY$2,
			LOAD_DATA_API: "load" + EVENT_KEY$2 + DATA_API_KEY$2,
			CLICK_DATA_API: "click" + EVENT_KEY$2 + DATA_API_KEY$2
			};
			var ClassName$2 = {
			CAROUSEL: 'carousel',
			ACTIVE: 'active',
			SLIDE: 'slide',
			RIGHT: 'carousel-item-right',
			LEFT: 'carousel-item-left',
			NEXT: 'carousel-item-next',
			PREV: 'carousel-item-prev',
			ITEM: 'carousel-item',
			POINTER_EVENT: 'pointer-event'
			};
			var Selector$2 = {
			ACTIVE: '.active',
			ACTIVE_ITEM: '.active.carousel-item',
			ITEM: '.carousel-item',
			ITEM_IMG: '.carousel-item img',
			NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
			INDICATORS: '.carousel-indicators',
			DATA_SLIDE: '[data-slide], [data-slide-to]',
			DATA_RIDE: '[data-ride="carousel"]'
			};
			var PointerType = {
			TOUCH: 'touch',
			PEN: 'pen'
			/**
			* ------------------------------------------------------------------------
			* Class Definition
			* ------------------------------------------------------------------------
			*/

			};

			var Carousel =
			/#__PURE__/
			function () {
			function Carousel(element, config) {
			this._items = null;
			this._interval = null;
			this._activeElement = null;
			this._isPaused = false;
			this._isSliding = false;
			this.touchTimeout = null;
			this.touchStartX = 0;
			this.touchDeltaX = 0;
			this._config = this._getConfig(config);
			this._element = element;
			this._indicatorsElement = this._element.querySelector(Selector$2.INDICATORS);
			this._touchSupported = 'ontouchstart' in document.documentElement \|\| navigator.maxTouchPoints > 0;
			this._pointerEvent = Boolean(window.PointerEvent \|\| window.MSPointerEvent);

			this._addEventListeners();
			} // Getters


			var _proto = Carousel.prototype;

			// Public
			_proto.next = function next() {
			if (!this._isSliding) {
			this._slide(Direction.NEXT);
			}
			};

			_proto.nextWhenVisible = function nextWhenVisible() {
			// Don't call next when the page isn't visible
			// or the carousel or its parent isn't visible
			if (!document.hidden && $(this._element).is(':visible') && $(this._element).css('visibility') !== 'hidden') {
			this.next();
			}
			};

			_proto.prev = function prev() {
			if (!this._isSliding) {
			this._slide(Direction.PREV);
			}
			};

			_proto.pause = function pause(event) {
			if (!event) {
			this._isPaused = true;
			}

			if (this._element.querySelector(Selector$2.NEXT_PREV)) {
			Util.triggerTransitionEnd(this._element);
			this.cycle(true);
			}

			clearInterval(this._interval);
			this._interval = null;
			};

			_proto.cycle = function cycle(event) {
			if (!event) {
			this._isPaused = false;
			}

			if (this._interval) {
			clearInterval(this._interval);
			this._interval = null;
			}

			if (this._config.interval && !this._isPaused) {
			this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
			}
			};

			_proto.to = function to(index) {
			var _this = this;

			this._activeElement = this._element.querySelector(Selector$2.ACTIVE_ITEM);

			var activeIndex = this._getItemIndex(this._activeElement);

			if (index > this._items.length - 1 \|\| index < 0) {
			return;
			}

			if (this._isSliding) {
			$(this._element).one(Event$2.SLID, function () {
			return _this.to(index);
			});
			return;
			}

			if (activeIndex === index) {
			this.pause();
			this.cycle();
			return;
			}

			var direction = index > activeIndex ? Direction.NEXT : Direction.PREV;

			this._slide(direction, this._items[index]);
			};

			_proto.dispose = function dispose() {
			$(this._element).off(EVENT_KEY$2);
			$.removeData(this._element, DATA_KEY$2);
			this._items = null;
			this._config = null;
			this._element = null;
			this._interval = null;
			this._isPaused = null;
			this._isSliding = null;
			this._activeElement = null;
			this._indicatorsElement = null;
			} // Private
			;

			_proto._getConfig = function _getConfig(config) {
			config = _objectSpread({}, Default, config);
			Util.typeCheckConfig(NAME$2, config, DefaultType);
			return config;
			};

			_proto._handleSwipe = function _handleSwipe() {
			var absDeltax = Math.abs(this.touchDeltaX);

			if (absDeltax <= SWIPE_THRESHOLD) {
			return;
			}

			var direction = absDeltax / this.touchDeltaX; // swipe left

			if (direction > 0) {
			this.prev();
			} // swipe right


			if (direction < 0) {
			this.next();
			}
			};

			_proto._addEventListeners = function _addEventListeners() {
			var _this2 = this;

			if (this._config.keyboard) {
			$(this._element).on(Event$2.KEYDOWN, function (event) {
			return _this2._keydown(event);
			});
			}

			if (this._config.pause === 'hover') {
			$(this._element).on(Event$2.MOUSEENTER, function (event) {
			return _this2.pause(event);
			}).on(Event$2.MOUSELEAVE, function (event) {
			return _this2.cycle(event);
			});
			}

			if (this._config.touch) {
			this._addTouchEventListeners();
			}
			};

			_proto._addTouchEventListeners = function _addTouchEventListeners() {
			var _this3 = this;

			if (!this._touchSupported) {
			return;
			}

			var start = function start(event) {
			if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) {
			_this3.touchStartX = event.originalEvent.clientX;
			} else if (!_this3._pointerEvent) {
			_this3.touchStartX = event.originalEvent.touches[0].clientX;
			}
			};

			var move = function move(event) {
			// ensure swiping with one touch and not pinching
			if (event.originalEvent.touches && event.originalEvent.touches.length > 1) {
			_this3.touchDeltaX = 0;
			} else {
			_this3.touchDeltaX = event.originalEvent.touches[0].clientX - _this3.touchStartX;
			}
			};

			var end = function end(event) {
			if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) {
			_this3.touchDeltaX = event.originalEvent.clientX - _this3.touchStartX;
			}

			_this3._handleSwipe();

			if (_this3._config.pause === 'hover') {
			// If it's a touch-enabled device, mouseenter/leave are fired as
			// part of the mouse compatibility events on first tap - the carousel
			// would stop cycling until user tapped out of it;
			// here, we listen for touchend, explicitly pause the carousel
			// (as if it's the second time we tap on it, mouseenter compat event
			// is NOT fired) and after a timeout (to allow for mouse compatibility
			// events to fire) we explicitly restart cycling
			_this3.pause();

			if (_this3.touchTimeout) {
			clearTimeout(_this3.touchTimeout);
			}

			_this3.touchTimeout = setTimeout(function (event) {
			return _this3.cycle(event);
			}, TOUCHEVENT_COMPAT_WAIT + _this3._config.interval);
			}
			};

			$(this._element.querySelectorAll(Selector$2.ITEM_IMG)).on(Event$2.DRAG_START, function (e) {
			return e.preventDefault();
			});

			if (this._pointerEvent) {
			$(this._element).on(Event$2.POINTERDOWN, function (event) {
			return start(event);
			});
			$(this._element).on(Event$2.POINTERUP, function (event) {
			return end(event);
			});

			this._element.classList.add(ClassName$2.POINTER_EVENT);
			} else {
			$(this._element).on(Event$2.TOUCHSTART, function (event) {
			return start(event);
			});
			$(this._element).on(Event$2.TOUCHMOVE, function (event) {
			return move(event);
			});
			$(this._element).on(Event$2.TOUCHEND, function (event) {
			return end(event);
			});
			}
			};

			_proto._keydown = function _keydown(event) {
			if (/input\|textarea/i.test(event.target.tagName)) {
			return;
			}

			switch (event.which) {
			case ARROW_LEFT_KEYCODE:
			event.preventDefault();
			this.prev();
			break;

			case ARROW_RIGHT_KEYCODE:
			event.preventDefault();
			this.next();
			break;

			default:
			}
			};

			_proto._getItemIndex = function _getItemIndex(element) {
			this._items = element && element.parentNode ? [].slice.call(element.parentNode.querySelectorAll(Selector$2.ITEM)) : [];
			return this._items.indexOf(element);
			};

			_proto._getItemByDirection = function _getItemByDirection(direction, activeElement) {
			var isNextDirection = direction === Direction.NEXT;
			var isPrevDirection = direction === Direction.PREV;

			var activeIndex = this._getItemIndex(activeElement);

			var lastItemIndex = this._items.length - 1;
			var isGoingToWrap = isPrevDirection && activeIndex === 0 \|\| isNextDirection && activeIndex === lastItemIndex;

			if (isGoingToWrap && !this._config.wrap) {
			return activeElement;
			}

			var delta = direction === Direction.PREV ? -1 : 1;
			var itemIndex = (activeIndex + delta) % this._items.length;
			return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
			};

			_proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) {
			var targetIndex = this._getItemIndex(relatedTarget);

			var fromIndex = this._getItemIndex(this._element.querySelector(Selector$2.ACTIVE_ITEM));

			var slideEvent = $.Event(Event$2.SLIDE, {
			relatedTarget: relatedTarget,
			direction: eventDirectionName,
			from: fromIndex,
			to: targetIndex
			});
			$(this._element).trigger(slideEvent);
			return slideEvent;
			};

			_proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) {
			if (this._indicatorsElement) {
			var indicators = [].slice.call(this._indicatorsElement.querySelectorAll(Selector$2.ACTIVE));
			$(indicators).removeClass(ClassName$2.ACTIVE);

			var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)];

			if (nextIndicator) {
			$(nextIndicator).addClass(ClassName$2.ACTIVE);
			}
			}
			};

			_proto._slide = function _slide(direction, element) {
			var _this4 = this;

			var activeElement = this._element.querySelector(Selector$2.ACTIVE_ITEM);

			var activeElementIndex = this._getItemIndex(activeElement);

			var nextElement = element \|\| activeElement && this._getItemByDirection(direction, activeElement);

			var nextElementIndex = this._getItemIndex(nextElement);

			var isCycling = Boolean(this._interval);
			var directionalClassName;
			var orderClassName;
			var eventDirectionName;

			if (direction === Direction.NEXT) {
			directionalClassName = ClassName$2.LEFT;
			orderClassName = ClassName$2.NEXT;
			eventDirectionName = Direction.LEFT;
			} else {
			directionalClassName = ClassName$2.RIGHT;
			orderClassName = ClassName$2.PREV;
			eventDirectionName = Direction.RIGHT;
			}

			if (nextElement && $(nextElement).hasClass(ClassName$2.ACTIVE)) {
			this._isSliding = false;
			return;
			}

			var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);

			if (slideEvent.isDefaultPrevented()) {
			return;
			}

			if (!activeElement \|\| !nextElement) {
			// Some weirdness is happening, so we bail
			return;
			}

			this._isSliding = true;

			if (isCycling) {
			this.pause();
			}

			this._setActiveIndicatorElement(nextElement);

			var slidEvent = $.Event(Event$2.SLID, {
			relatedTarget: nextElement,
			direction: eventDirectionName,
			from: activeElementIndex,
			to: nextElementIndex
			});

			if ($(this._element).hasClass(ClassName$2.SLIDE)) {
			$(nextElement).addClass(orderClassName);
			Util.reflow(nextElement);
			$(activeElement).addClass(directionalClassName);
			$(nextElement).addClass(directionalClassName);
			var nextElementInterval = parseInt(nextElement.getAttribute('data-interval'), 10);

			if (nextElementInterval) {
			this._config.defaultInterval = this._config.defaultInterval \|\| this._config.interval;
			this._config.interval = nextElementInterval;
			} else {
			this._config.interval = this._config.defaultInterval \|\| this._config.interval;
			}

			var transitionDuration = Util.getTransitionDurationFromElement(activeElement);
			$(activeElement).one(Util.TRANSITION_END, function () {
			$(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName$2.ACTIVE);
			$(activeElement).removeClass(ClassName$2.ACTIVE + " " + orderClassName + " " + directionalClassName);
			_this4._isSliding = false;
			setTimeout(function () {
			return $(_this4._element).trigger(slidEvent);
			}, 0);
			}).emulateTransitionEnd(transitionDuration);
			} else {
			$(activeElement).removeClass(ClassName$2.ACTIVE);
			$(nextElement).addClass(ClassName$2.ACTIVE);
			this._isSliding = false;
			$(this._element).trigger(slidEvent);
			}

			if (isCycling) {
			this.cycle();
			}
			} // Static
			;

			Carousel._jQueryInterface = function _jQueryInterface(config) {
			return this.each(function () {
			var data = $(this).data(DATA_KEY$2);

			var _config = _objectSpread({}, Default, $(this).data());

			if (typeof config === 'object') {
			_config = _objectSpread({}, _config, config);
			}

			var action = typeof config === 'string' ? config : _config.slide;

			if (!data) {
			data = new Carousel(this, _config);
			$(this).data(DATA_KEY$2, data);
			}

			if (typeof config === 'number') {
			data.to(config);
			} else if (typeof action === 'string') {
			if (typeof data[action] === 'undefined') {
			throw new TypeError("No method named \"" + action + "\"");
			}

			data[action]();
			} else if (_config.interval && _config.ride) {
			data.pause();
			data.cycle();
			}
			});
			};

			Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
			var selector = Util.getSelectorFromElement(this);

			if (!selector) {
			return;
			}

			var target = $(selector)[0];

			if (!target \|\| !$(target).hasClass(ClassName$2.CAROUSEL)) {
			return;
			}

			var config = _objectSpread({}, $(target).data(), $(this).data());

			var slideIndex = this.getAttribute('data-slide-to');

			if (slideIndex) {
			config.interval = false;
			}

			Carousel._jQueryInterface.call($(target), config);

			if (slideIndex) {
			$(target).data(DATA_KEY$2).to(slideIndex);
			}

			event.preventDefault();
			};

			_createClass(Carousel, null, [{
			key: "VERSION",
			get: function get() {
			return VERSION$2;
			}
			}, {
			key: "Default",
			get: function get() {
			return Default;
			}
			}]);

			return Carousel;
			}();
			/**
			* ------------------------------------------------------------------------
			* Data Api implementation
			* ------------------------------------------------------------------------
			*/


			$(document).on(Event$2.CLICK_DATA_API, Selector$2.DATA_SLIDE, Carousel._dataApiClickHandler);
			$(window).on(Event$2.LOAD_DATA_API, function () {
			var carousels = [].slice.call(document.querySelectorAll(Selector$2.DATA_RIDE));

			for (var i = 0, len = carousels.length; i < len; i++) {
			var $carousel = $(carousels[i]);

			Carousel._jQueryInterface.call($carousel, $carousel.data());
			}
			});
			/**
			* ------------------------------------------------------------------------
			* jQuery
			* ------------------------------------------------------------------------
			*/

			$.fn[NAME$2] = Carousel._jQueryInterface;
			$.fn[NAME$2].Constructor = Carousel;

			$.fn[NAME$2].noConflict = function () {
			$.fn[NAME$2] = JQUERY_NO_CONFLICT$2;
			return Carousel._jQueryInterface;
			};

			/**
			* ------------------------------------------------------------------------
			* Constants
			* ------------------------------------------------------------------------
			*/

			var NAME$3 = 'collapse';
			var VERSION$3 = '4.3.1';
			var DATA_KEY$3 = 'bs.collapse';
			var EVENT_KEY$3 = "." + DATA_KEY$3;
			var DATA_API_KEY$3 = '.data-api';
			var JQUERY_NO_CONFLICT$3 = $.fn[NAME$3];
			var Default$1 = {
			toggle: true,
			parent: ''
			};
			var DefaultType$1 = {
			toggle: 'boolean',
			parent: '(string\|element)'
			};
			var Event$3 = {
			SHOW: "show" + EVENT_KEY$3,
			SHOWN: "shown" + EVENT_KEY$3,
			HIDE: "hide" + EVENT_KEY$3,
			HIDDEN: "hidden" + EVENT_KEY$3,
			CLICK_DATA_API: "click" + EVENT_KEY$3 + DATA_API_KEY$3
			};
			var ClassName$3 = {
			SHOW: 'show',
			COLLAPSE: 'collapse',
			COLLAPSING: 'collapsing',
			COLLAPSED: 'collapsed'
			};
			var Dimension = {
			WIDTH: 'width',
			HEIGHT: 'height'
			};
			var Selector$3 = {
			ACTIVES: '.show, .collapsing',
			DATA_TOGGLE: '[data-toggle="collapse"]'
			/**
			* ------------------------------------------------------------------------
			* Class Definition
			* ------------------------------------------------------------------------
			*/

			};

			var Collapse =
			/#__PURE__/
			function () {
			function Collapse(element, config) {
			this._isTransitioning = false;
			this._element = element;
			this._config = this._getConfig(config);
			this._triggerArray = [].slice.call(document.querySelectorAll("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]")));
			var toggleList = [].slice.call(document.querySelectorAll(Selector$3.DATA_TOGGLE));

			for (var i = 0, len = toggleList.length; i < len; i++) {
			var elem = toggleList[i];
			var selector = Util.getSelectorFromElement(elem);
			var filterElement = [].slice.call(document.querySelectorAll(selector)).filter(function (foundElem) {
			return foundElem === element;
			});

			if (selector !== null && filterElement.length > 0) {
			this._selector = selector;

			this._triggerArray.push(elem);
			}
			}

			this._parent = this._config.parent ? this._getParent() : null;

			if (!this._config.parent) {
			this._addAriaAndCollapsedClass(this._element, this._triggerArray);
			}

			if (this._config.toggle) {
			this.toggle();
			}
			} // Getters


			var _proto = Collapse.prototype;

			// Public
			_proto.toggle = function toggle() {
			if ($(this._element).hasClass(ClassName$3.SHOW)) {
			this.hide();
			} else {
			this.show();
			}
			};

			_proto.show = function show() {
			var _this = this;

			if (this._isTransitioning \|\| $(this._element).hasClass(ClassName$3.SHOW)) {
			return;
			}

			var actives;
			var activesData;

			if (this._parent) {
			actives = [].slice.call(this._parent.querySelectorAll(Selector$3.ACTIVES)).filter(function (elem) {
			if (typeof _this._config.parent === 'string') {
			return elem.getAttribute('data-parent') === _this._config.parent;
			}

			return elem.classList.contains(ClassName$3.COLLAPSE);
			});

			if (actives.length === 0) {
			actives = null;
			}
			}

			if (actives) {
			activesData = $(actives).not(this._selector).data(DATA_KEY$3);

			if (activesData && activesData._isTransitioning) {
			return;
			}
			}

			var startEvent = $.Event(Event$3.SHOW);
			$(this._element).trigger(startEvent);

			if (startEvent.isDefaultPrevented()) {
			return;
			}

			if (actives) {
			Collapse._jQueryInterface.call($(actives).not(this._selector), 'hide');

			if (!activesData) {
			$(actives).data(DATA_KEY$3, null);
			}
			}

			var dimension = this._getDimension();

			$(this._element).removeClass(ClassName$3.COLLAPSE).addClass(ClassName$3.COLLAPSING);
			this._element.style[dimension] = 0;

			if (this._triggerArray.length) {
			$(this._triggerArray).removeClass(ClassName$3.COLLAPSED).attr('aria-expanded', true);
			}

			this.setTransitioning(true);

			var complete = function complete() {
			$(_this._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).addClass(ClassName$3.SHOW);
			_this._element.style[dimension] = '';

			_this.setTransitioning(false);

			$(_this._element).trigger(Event$3.SHOWN);
			};

			var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
			var scrollSize = "scroll" + capitalizedDimension;
			var transitionDuration = Util.getTransitionDurationFromElement(this._element);
			$(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
			this._element.style[dimension] = this._element[scrollSize] + "px";
			};

			_proto.hide = function hide() {
			var _this2 = this;

			if (this._isTransitioning \|\| !$(this._element).hasClass(ClassName$3.SHOW)) {
			return;
			}

			var startEvent = $.Event(Event$3.HIDE);
			$(this._element).trigger(startEvent);

			if (startEvent.isDefaultPrevented()) {
			return;
			}

			var dimension = this._getDimension();

			this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px";
			Util.reflow(this._element);
			$(this._element).addClass(ClassName$3.COLLAPSING).removeClass(ClassName$3.COLLAPSE).removeClass(ClassName$3.SHOW);
			var triggerArrayLength = this._triggerArray.length;

			if (triggerArrayLength > 0) {
			for (var i = 0; i < triggerArrayLength; i++) {
			var trigger = this._triggerArray[i];
			var selector = Util.getSelectorFromElement(trigger);

			if (selector !== null) {
			var $elem = $([].slice.call(document.querySelectorAll(selector)));

			if (!$elem.hasClass(ClassName$3.SHOW)) {
			$(trigger).addClass(ClassName$3.COLLAPSED).attr('aria-expanded', false);
			}
			}
			}
			}

			this.setTransitioning(true);

			var complete = function complete() {
			_this2.setTransitioning(false);

			$(_this2._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).trigger(Event$3.HIDDEN);
			};

			this._element.style[dimension] = '';
			var transitionDuration = Util.getTransitionDurationFromElement(this._element);
			$(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration);
			};

			_proto.setTransitioning = function setTransitioning(isTransitioning) {
			this._isTransitioning = isTransitioning;
			};

			_proto.dispose = function dispose() {
			$.removeData(this._element, DATA_KEY$3);
			this._config = null;
			this._parent = null;
			this._element = null;
			this._triggerArray = null;
			this._isTransitioning = null;
			} // Private
			;

			_proto._getConfig = function _getConfig(config) {
			config = _objectSpread({}, Default$1, config);
			config.toggle = Boolean(config.toggle); // Coerce string values

			Util.typeCheckConfig(NAME$3, config, DefaultType$1);
			return config;
			};

			_proto._getDimension = function _getDimension() {
			var hasWidth = $(this._element).hasClass(Dimension.WIDTH);
			return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT;
			};

			_proto._getParent = function _getParent() {
			var _this3 = this;

			var parent;

			if (Util.isElement(this._config.parent)) {
			parent = this._config.parent; // It's a jQuery object

			if (typeof this._config.parent.jquery !== 'undefined') {
			parent = this._config.parent[0];
			}
			} else {
			parent = document.querySelector(this._config.parent);
			}

			var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]";
			var children = [].slice.call(parent.querySelectorAll(selector));
			$(children).each(function (i, element) {
			_this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]);
			});
			return parent;
			};

			_proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) {
			var isOpen = $(element).hasClass(ClassName$3.SHOW);

			if (triggerArray.length) {
			$(triggerArray).toggleClass(ClassName$3.COLLAPSED, !isOpen).attr('aria-expanded', isOpen);
			}
			} // Static
			;

			Collapse._getTargetFromElement = function _getTargetFromElement(element) {
			var selector = Util.getSelectorFromElement(element);
			return selector ? document.querySelector(selector) : null;
			};

			Collapse._jQueryInterface = function _jQueryInterface(config) {
			return this.each(function () {
			var $this = $(this);
			var data = $this.data(DATA_KEY$3);

			var _config = _objectSpread({}, Default$1, $this.data(), typeof config === 'object' && config ? config : {});

			if (!data && _config.toggle && /show\|hide/.test(config)) {
			_config.toggle = false;
			}

			if (!data) {
			data = new Collapse(this, _config);
			$this.data(DATA_KEY$3, data);
			}

			if (typeof config === 'string') {
			if (typeof data[config] === 'undefined') {
			throw new TypeError("No method named \"" + config + "\"");
			}

			data[config]();
			}
			});
			};

			_createClass(Collapse, null, [{
			key: "VERSION",
			get: function get() {
			return VERSION$3;
			}
			}, {
			key: "Default",
			get: function get() {
			return Default$1;
			}
			}]);

			return Collapse;
			}();
			/**
			* ------------------------------------------------------------------------
			* Data Api implementation
			* ------------------------------------------------------------------------
			*/


			$(document).on(Event$3.CLICK_DATA_API, Selector$3.DATA_TOGGLE, function (event) {
			// preventDefault only for <a> elements (which change the URL) not inside the collapsible element
			if (event.currentTarget.tagName === 'A') {
			event.preventDefault();
			}

			var $trigger = $(this);
			var selector = Util.getSelectorFromElement(this);
			var selectors = [].slice.call(document.querySelectorAll(selector));
			$(selectors).each(function () {
			var $target = $(this);
			var data = $target.data(DATA_KEY$3);
			var config = data ? 'toggle' : $trigger.data();

			Collapse._jQueryInterface.call($target, config);
			});
			});
			/**
			* ------------------------------------------------------------------------
			* jQuery
			* ------------------------------------------------------------------------
			*/

			$.fn[NAME$3] = Collapse._jQueryInterface;
			$.fn[NAME$3].Constructor = Collapse;

			$.fn[NAME$3].noConflict = function () {
			$.fn[NAME$3] = JQUERY_NO_CONFLICT$3;
			return Collapse._jQueryInterface;
			};

			/**!
			* @fileOverview Kickass library to create and place poppers near their reference elements.
			* @version 1.14.7
			* @license
			* Copyright (c) 2016 Federico Zivolo and contributors
			*
			* Permission is hereby granted, free of charge, to any person obtaining a copy
			* of this software and associated documentation files (the "Software"), to deal
			* in the Software without restriction, including without limitation the rights
			* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
			* copies of the Software, and to permit persons to whom the Software is
			* furnished to do so, subject to the following conditions:
			*
			* The above copyright notice and this permission notice shall be included in all
			* copies or substantial portions of the Software.
			*
			* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
			* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
			* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
			* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
			* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
			* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
			* SOFTWARE.
			*/
			var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';

			var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
			var timeoutDuration = 0;
			for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
			if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
			timeoutDuration = 1;
			break;
			}
			}

			function microtaskDebounce(fn) {
			var called = false;
			return function () {
			if (called) {
			return;
			}
			called = true;
			window.Promise.resolve().then(function () {
			called = false;
			fn();
			});
			};
			}

			function taskDebounce(fn) {
			var scheduled = false;
			return function () {
			if (!scheduled) {
			scheduled = true;
			setTimeout(function () {
			scheduled = false;
			fn();
			}, timeoutDuration);
			}
			};
			}

			var supportsMicroTasks = isBrowser && window.Promise;

			/**
			* Create a debounced version of a method, that's asynchronously deferred
			* but called in the minimum time possible.
			*
			* @method
			* @memberof Popper.Utils
			* @argument {Function} fn
			* @returns {Function}
			*/
			var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;

			/**
			* Check if the given variable is a function
			* @method
			* @memberof Popper.Utils
			* @argument {Any} functionToCheck - variable to check
			* @returns {Boolean} answer to: is a function?
			*/
			function isFunction(functionToCheck) {
			var getType = {};
			return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
			}

			/**
			* Get CSS computed property of the given element
			* @method
			* @memberof Popper.Utils
			* @argument {Eement} element
			* @argument {String} property
			*/
			function getStyleComputedProperty(element, property) {
			if (element.nodeType !== 1) {
			return [];
			}
			// NOTE: 1 DOM access here
			var window = element.ownerDocument.defaultView;
			var css = window.getComputedStyle(element, null);
			return property ? css[property] : css;
			}

			/**
			* Returns the parentNode or the host of the element
			* @method
			* @memberof Popper.Utils
			* @argument {Element} element
			* @returns {Element} parent
			*/
			function getParentNode(element) {
			if (element.nodeName === 'HTML') {
			return element;
			}
			return element.parentNode \|\| element.host;
			}

			/**
			* Returns the scrolling parent of the given element
			* @method
			* @memberof Popper.Utils
			* @argument {Element} element
			* @returns {Element} scroll parent
			*/
			function getScrollParent(element) {
			// Return body, `getScroll` will take care to get the correct `scrollTop` from it
			if (!element) {
			return document.body;
			}

			switch (element.nodeName) {
			case 'HTML':
			case 'BODY':
			return element.ownerDocument.body;
			case '#document':
			return element.body;
			}

			// Firefox want us to check `-x` and `-y` variations as well

			var _getStyleComputedProp = getStyleComputedProperty(element),
			overflow = _getStyleComputedProp.overflow,
			overflowX = _getStyleComputedProp.overflowX,
			overflowY = _getStyleComputedProp.overflowY;

			if (/(auto\|scroll\|overlay)/.test(overflow + overflowY + overflowX)) {
			return element;
			}

			return getScrollParent(getParentNode(element));
			}

			var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
			var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);

			/**
			* Determines if the browser is Internet Explorer
			* @method
			* @memberof Popper.Utils
			* @param {Number} version to check
			* @returns {Boolean} isIE
			*/
			function isIE(version) {
			if (version === 11) {
			return isIE11;
			}
			if (version === 10) {
			return isIE10;
			}
			return isIE11 \|\| isIE10;
			}

			/**
			* Returns the offset parent of the given element
			* @method
			* @memberof Popper.Utils
			* @argument {Element} element
			* @returns {Element} offset parent
			*/
			function getOffsetParent(element) {
			if (!element) {
			return document.documentElement;
			}

			var noOffsetParent = isIE(10) ? document.body : null;

			// NOTE: 1 DOM access here
			var offsetParent = element.offsetParent \|\| null;
			// Skip hidden elements which don't have an offsetParent
			while (offsetParent === noOffsetParent && element.nextElementSibling) {
			offsetParent = (element = element.nextElementSibling).offsetParent;
			}

			var nodeName = offsetParent && offsetParent.nodeName;

			if (!nodeName \|\| nodeName === 'BODY' \|\| nodeName === 'HTML') {
			return element ? element.ownerDocument.documentElement : document.documentElement;
			}

			// .offsetParent will return the closest TH, TD or TABLE in case
			// no offsetParent is present, I hate this job...
			if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
			return getOffsetParent(offsetParent);
			}

			return offsetParent;
			}

			function isOffsetContainer(element) {
			var nodeName = element.nodeName;

			if (nodeName === 'BODY') {
			return false;
			}
			return nodeName === 'HTML' \|\| getOffsetParent(element.firstElementChild) === element;
			}

			/**
			* Finds the root node (document, shadowDOM root) of the given element
			* @method
			* @memberof Popper.Utils
			* @argument {Element} node
			* @returns {Element} root node
			*/
			function getRoot(node) {
			if (node.parentNode !== null) {
			return getRoot(node.parentNode);
			}

			return node;
			}

			/**
			* Finds the offset parent common to the two provided nodes
			* @method
			* @memberof Popper.Utils
			* @argument {Element} element1
			* @argument {Element} element2
			* @returns {Element} common offset parent
			*/
			function findCommonOffsetParent(element1, element2) {
			// This check is needed to avoid errors in case one of the elements isn't defined for any reason
			if (!element1 \|\| !element1.nodeType \|\| !element2 \|\| !element2.nodeType) {
			return document.documentElement;
			}

			// Here we make sure to give as "start" the element that comes first in the DOM
			var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
			var start = order ? element1 : element2;
			var end = order ? element2 : element1;

			// Get common ancestor container
			var range = document.createRange();
			range.setStart(start, 0);
			range.setEnd(end, 0);
			var commonAncestorContainer = range.commonAncestorContainer;

			// Both nodes are inside #document

			if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer \|\| start.contains(end)) {
			if (isOffsetContainer(commonAncestorContainer)) {
			return commonAncestorContainer;
			}

			return getOffsetParent(commonAncestorContainer);
			}

			// one of the nodes is inside shadowDOM, find which one
			var element1root = getRoot(element1);
			if (element1root.host) {
			return findCommonOffsetParent(element1root.host, element2);
			} else {
			return findCommonOffsetParent(element1, getRoot(element2).host);
			}
			}

			/**
			* Gets the scroll value of the given element in the given side (top and left)
			* @method
			* @memberof Popper.Utils
			* @argument {Element} element
			* @argument {String} side `top` or `left`
			* @returns {number} amount of scrolled pixels
			*/
			function getScroll(element) {
			var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';

			var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
			var nodeName = element.nodeName;

			if (nodeName === 'BODY' \|\| nodeName === 'HTML') {
			var html = element.ownerDocument.documentElement;
			var scrollingElement = element.ownerDocument.scrollingElement \|\| html;
			return scrollingElement[upperSide];
			}

			return element[upperSide];
			}

			/*
			* Sum or subtract the element scroll values (left and top) from a given rect object
			* @method
			* @memberof Popper.Utils
			* @param {Object} rect - Rect object you want to change
			* @param {HTMLElement} element - The element from the function reads the scroll values
			* @param {Boolean} subtract - set to true if you want to subtract the scroll values
			* @return {Object} rect - The modifier rect object
			*/
			function includeScroll(rect, element) {
			var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

			var scrollTop = getScroll(element, 'top');
			var scrollLeft = getScroll(element, 'left');
			var modifier = subtract ? -1 : 1;
			rect.top += scrollTop * modifier;
			rect.bottom += scrollTop * modifier;
			rect.left += scrollLeft * modifier;
			rect.right += scrollLeft * modifier;
			return rect;
			}

			/*
			* Helper to detect borders of a given element
			* @method
			* @memberof Popper.Utils
			* @param {CSSStyleDeclaration} styles
			* Result of `getStyleComputedProperty` on the given element
			* @param {String} axis - `x` or `y`
			* @return {number} borders - The borders size of the given axis
			*/

			function getBordersSize(styles, axis) {
			var sideA = axis === 'x' ? 'Left' : 'Top';
			var sideB = sideA === 'Left' ? 'Right' : 'Bottom';

			return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10);
			}

			function getSize(axis, body, html, computedStyle) {
			return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0);
			}

			function getWindowSizes(document) {
			var body = document.body;
			var html = document.documentElement;
			var computedStyle = isIE(10) && getComputedStyle(html);

			return {
			height: getSize('Height', body, html, computedStyle),
			width: getSize('Width', body, html, computedStyle)
			};
			}

			var classCallCheck = function (instance, Constructor) {
			if (!(instance instanceof Constructor)) {
			throw new TypeError("Cannot call a class as a function");
			}
			};

			var createClass = function () {
			function defineProperties(target, props) {
			for (var i = 0; i < props.length; i++) {
			var descriptor = props[i];
			descriptor.enumerable = descriptor.enumerable \|\| false;
			descriptor.configurable = true;
			if ("value" in descriptor) descriptor.writable = true;
			Object.defineProperty(target, descriptor.key, descriptor);
			}
			}

			return function (Constructor, protoProps, staticProps) {
			if (protoProps) defineProperties(Constructor.prototype, protoProps);
			if (staticProps) defineProperties(Constructor, staticProps);
			return Constructor;
			};
			}();





			var defineProperty = function (obj, key, value) {
			if (key in obj) {
			Object.defineProperty(obj, key, {
			value: value,
			enumerable: true,
			configurable: true,
			writable: true
			});
			} else {
			obj[key] = value;
			}

			return obj;
			};

			var _extends = Object.assign \|\| function (target) {
			for (var i = 1; i < arguments.length; i++) {
			var source = arguments[i];

			for (var key in source) {
			if (Object.prototype.hasOwnProperty.call(source, key)) {
			target[key] = source[key];
			}
			}
			}

			return target;
			};

			/**
			* Given element offsets, generate an output similar to getBoundingClientRect
			* @method
			* @memberof Popper.Utils
			* @argument {Object} offsets
			* @returns {Object} ClientRect like output
			*/
			function getClientRect(offsets) {
			return _extends({}, offsets, {
			right: offsets.left + offsets.width,
			bottom: offsets.top + offsets.height
			});
			}

			/**
			* Get bounding client rect of given element
			* @method
			* @memberof Popper.Utils
			* @param {HTMLElement} element
			* @return {Object} client rect
			*/
			function getBoundingClientRect(element) {
			var rect = {};

			// IE10 10 FIX: Please, don't ask, the element isn't
			// considered in DOM in some circumstances...
			// This isn't reproducible in IE10 compatibility mode of IE11
			try {
			if (isIE(10)) {
			rect = element.getBoundingClientRect();
			var scrollTop = getScroll(element, 'top');
			var scrollLeft = getScroll(element, 'left');
			rect.top += scrollTop;
			rect.left += scrollLeft;
			rect.bottom += scrollTop;
			rect.right += scrollLeft;
			} else {
			rect = element.getBoundingClientRect();
			}
			} catch (e) {}

			var result = {
			left: rect.left,
			top: rect.top,
			width: rect.right - rect.left,
			height: rect.bottom - rect.top
			};

			// subtract scrollbar size from sizes
			var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};
			var width = sizes.width \|\| element.clientWidth \|\| result.right - result.left;
			var height = sizes.height \|\| element.clientHeight \|\| result.bottom - result.top;

			var horizScrollbar = element.offsetWidth - width;
			var vertScrollbar = element.offsetHeight - height;

			// if an hypothetical scrollbar is detected, we must be sure it's not a `border`
			// we make this check conditional for performance reasons
			if (horizScrollbar \|\| vertScrollbar) {
			var styles = getStyleComputedProperty(element);
			horizScrollbar -= getBordersSize(styles, 'x');
			vertScrollbar -= getBordersSize(styles, 'y');

			result.width -= horizScrollbar;
			result.height -= vertScrollbar;
			}

			return getClientRect(result);
			}

			function getOffsetRectRelativeToArbitraryNode(children, parent) {
			var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

			var isIE10 = isIE(10);
			var isHTML = parent.nodeName === 'HTML';
			var childrenRect = getBoundingClientRect(children);
			var parentRect = getBoundingClientRect(parent);
			var scrollParent = getScrollParent(children);

			var styles = getStyleComputedProperty(parent);
			var borderTopWidth = parseFloat(styles.borderTopWidth, 10);
			var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10);

			// In cases where the parent is fixed, we must ignore negative scroll in offset calc
			if (fixedPosition && isHTML) {
			parentRect.top = Math.max(parentRect.top, 0);
			parentRect.left = Math.max(parentRect.left, 0);
			}
			var offsets = getClientRect({
			top: childrenRect.top - parentRect.top - borderTopWidth,
			left: childrenRect.left - parentRect.left - borderLeftWidth,
			width: childrenRect.width,
			height: childrenRect.height
			});
			offsets.marginTop = 0;
			offsets.marginLeft = 0;

			// Subtract margins of documentElement in case it's being used as parent
			// we do this only on HTML because it's the only element that behaves
			// differently when margins are applied to it. The margins are included in
			// the box of the documentElement, in the other cases not.
			if (!isIE10 && isHTML) {
			var marginTop = parseFloat(styles.marginTop, 10);
			var marginLeft = parseFloat(styles.marginLeft, 10);

			offsets.top -= borderTopWidth - marginTop;
			offsets.bottom -= borderTopWidth - marginTop;
			offsets.left -= borderLeftWidth - marginLeft;
			offsets.right -= borderLeftWidth - marginLeft;

			// Attach marginTop and marginLeft because in some circumstances we may need them
			offsets.marginTop = marginTop;
			offsets.marginLeft = marginLeft;
			}

			if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
			offsets = includeScroll(offsets, parent);
			}

			return offsets;
			}

			function getViewportOffsetRectRelativeToArtbitraryNode(element) {
			var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

			var html = element.ownerDocument.documentElement;
			var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
			var width = Math.max(html.clientWidth, window.innerWidth \|\| 0);
			var height = Math.max(html.clientHeight, window.innerHeight \|\| 0);

			var scrollTop = !excludeScroll ? getScroll(html) : 0;
			var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;

			var offset = {
			top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
			left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
			width: width,
			height: height
			};

			return getClientRect(offset);
			}

			/**
			* Check if the given element is fixed or is inside a fixed parent
			* @method
			* @memberof Popper.Utils
			* @argument {Element} element
			* @argument {Element} customContainer
			* @returns {Boolean} answer to "isFixed?"
			*/
			function isFixed(element) {
			var nodeName = element.nodeName;
			if (nodeName === 'BODY' \|\| nodeName === 'HTML') {
			return false;
			}
			if (getStyleComputedProperty(element, 'position') === 'fixed') {
			return true;
			}
			var parentNode = getParentNode(element);
			if (!parentNode) {
			return false;
			}
			return isFixed(parentNode);
			}

			/**
			* Finds the first parent of an element that has a transformed property defined
			* @method
			* @memberof Popper.Utils
			* @argument {Element} element
			* @returns {Element} first transformed parent or documentElement
			*/

			function getFixedPositionOffsetParent(element) {
			// This check is needed to avoid errors in case one of the elements isn't defined for any reason
			if (!element \|\| !element.parentElement \|\| isIE()) {
			return document.documentElement;
			}
			var el = element.parentElement;
			while (el && getStyleComputedProperty(el, 'transform') === 'none') {
			el = el.parentElement;
			}
			return el \|\| document.documentElement;
			}

			/**
			* Computed the boundaries limits and return them
			* @method
			* @memberof Popper.Utils
			* @param {HTMLElement} popper
			* @param {HTMLElement} reference
			* @param {number} padding
			* @param {HTMLElement} boundariesElement - Element used to define the boundaries
			* @param {Boolean} fixedPosition - Is in fixed position mode
			* @returns {Object} Coordinates of the boundaries
			*/
			function getBoundaries(popper, reference, padding, boundariesElement) {
			var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;

			// NOTE: 1 DOM access here

			var boundaries = { top: 0, left: 0 };
			var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);

			// Handle viewport case
			if (boundariesElement === 'viewport') {
			boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
			} else {
			// Handle other cases based on DOM element used as boundaries
			var boundariesNode = void 0;
			if (boundariesElement === 'scrollParent') {
			boundariesNode = getScrollParent(getParentNode(reference));
			if (boundariesNode.nodeName === 'BODY') {
			boundariesNode = popper.ownerDocument.documentElement;
			}
			} else if (boundariesElement === 'window') {
			boundariesNode = popper.ownerDocument.documentElement;
			} else {
			boundariesNode = boundariesElement;
			}

			var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);

			// In case of HTML, we need a different computation
			if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
			var _getWindowSizes = getWindowSizes(popper.ownerDocument),
			height = _getWindowSizes.height,
			width = _getWindowSizes.width;

			boundaries.top += offsets.top - offsets.marginTop;
			boundaries.bottom = height + offsets.top;
			boundaries.left += offsets.left - offsets.marginLeft;
			boundaries.right = width + offsets.left;
			} else {
			// for all the other DOM elements, this one is good
			boundaries = offsets;
			}
			}

			// Add paddings
			padding = padding \|\| 0;
			var isPaddingNumber = typeof padding === 'number';
			boundaries.left += isPaddingNumber ? padding : padding.left \|\| 0;
			boundaries.top += isPaddingNumber ? padding : padding.top \|\| 0;
			boundaries.right -= isPaddingNumber ? padding : padding.right \|\| 0;
			boundaries.bottom -= isPaddingNumber ? padding : padding.bottom \|\| 0;

			return boundaries;
			}

			function getArea(_ref) {
			var width = _ref.width,
			height = _ref.height;

			return width * height;
			}

			/**
			* Utility used to transform the `auto` placement to the placement with more
			* available space.
			* @method
			* @memberof Popper.Utils
			* @argument {Object} data - The data object generated by update method
			* @argument {Object} options - Modifiers configuration and options
			* @returns {Object} The data object, properly modified
			*/
			function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
			var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;

			if (placement.indexOf('auto') === -1) {
			return placement;
			}

			var boundaries = getBoundaries(popper, reference, padding, boundariesElement);

			var rects = {
			top: {
			width: boundaries.width,
			height: refRect.top - boundaries.top
			},
			right: {
			width: boundaries.right - refRect.right,
			height: boundaries.height
			},
			bottom: {
			width: boundaries.width,
			height: boundaries.bottom - refRect.bottom
			},
			left: {
			width: refRect.left - boundaries.left,
			height: boundaries.height
			}
			};

			var sortedAreas = Object.keys(rects).map(function (key) {
			return _extends({
			key: key
			}, rects[key], {
			area: getArea(rects[key])
			});
			}).sort(function (a, b) {
			return b.area - a.area;
			});

			var filteredAreas = sortedAreas.filter(function (_ref2) {
			var width = _ref2.width,
			height = _ref2.height;
			return width >= popper.clientWidth && height >= popper.clientHeight;
			});

			var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;

			var variation = placement.split('-')[1];

			return computedPlacement + (variation ? '-' + variation : '');
			}

			/**
			* Get offsets to the reference element
			* @method
			* @memberof Popper.Utils
			* @param {Object} state
			* @param {Element} popper - the popper element
			* @param {Element} reference - the reference element (the popper will be relative to this)
			* @param {Element} fixedPosition - is in fixed position mode
			* @returns {Object} An object containing the offsets which will be applied to the popper
			*/
			function getReferenceOffsets(state, popper, reference) {
			var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;

			var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);
			return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
			}

			/**
			* Get the outer sizes of the given element (offset size + margins)
			* @method
			* @memberof Popper.Utils
			* @argument {Element} element
			* @returns {Object} object containing width and height properties
			*/
			function getOuterSizes(element) {
			var window = element.ownerDocument.defaultView;
			var styles = window.getComputedStyle(element);
			var x = parseFloat(styles.marginTop \|\| 0) + parseFloat(styles.marginBottom \|\| 0);
			var y = parseFloat(styles.marginLeft \|\| 0) + parseFloat(styles.marginRight \|\| 0);
			var result = {
			width: element.offsetWidth + y,
			height: element.offsetHeight + x
			};
			return result;
			}

			/**
			* Get the opposite placement of the given one
			* @method
			* @memberof Popper.Utils
			* @argument {String} placement
			* @returns {String} flipped placement
			*/
			function getOppositePlacement(placement) {
			var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
			return placement.replace(/left\|right\|bottom\|top/g, function (matched) {
			return hash[matched];
			});
			}

			/**
			* Get offsets to the popper
			* @method
			* @memberof Popper.Utils
			* @param {Object} position - CSS position the Popper will get applied
			* @param {HTMLElement} popper - the popper element
			* @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
			* @param {String} placement - one of the valid placement options
			* @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
			*/
			function getPopperOffsets(popper, referenceOffsets, placement) {
			placement = placement.split('-')[0];

			// Get popper node sizes
			var popperRect = getOuterSizes(popper);

			// Add position, width and height to our offsets object
			var popperOffsets = {
			width: popperRect.width,
			height: popperRect.height
			};

			// depending by the popper placement we have to compute its offsets slightly differently
			var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
			var mainSide = isHoriz ? 'top' : 'left';
			var secondarySide = isHoriz ? 'left' : 'top';
			var measurement = isHoriz ? 'height' : 'width';
			var secondaryMeasurement = !isHoriz ? 'height' : 'width';

			popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
			if (placement === secondarySide) {
			popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
			} else {
			popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
			}

			return popperOffsets;
			}

			/**
			* Mimics the `find` method of Array
			* @method
			* @memberof Popper.Utils
			* @argument {Array} arr
			* @argument prop
			* @argument value
			* @returns index or -1
			*/
			function find(arr, check) {
			// use native find if supported
			if (Array.prototype.find) {
			return arr.find(check);
			}

			// use `filter` to obtain the same behavior of `find`
			return arr.filter(check)[0];
			}

			/**
			* Return the index of the matching object
			* @method
			* @memberof Popper.Utils
			* @argument {Array} arr
			* @argument prop
			* @argument value
			* @returns index or -1
			*/
			function findIndex(arr, prop, value) {
			// use native findIndex if supported
			if (Array.prototype.findIndex) {
			return arr.findIndex(function (cur) {
			return cur[prop] === value;
			});
			}

			// use `find` + `indexOf` if `findIndex` isn't supported
			var match = find(arr, function (obj) {
			return obj[prop] === value;
			});
			return arr.indexOf(match);
			}

			/**
			* Loop trough the list of modifiers and run them in order,
			* each of them will then edit the data object.
			* @method
			* @memberof Popper.Utils
			* @param {dataObject} data
			* @param {Array} modifiers
			* @param {String} ends - Optional modifier name used as stopper
			* @returns {dataObject}
			*/
			function runModifiers(modifiers, data, ends) {
			var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));

			modifiersToRun.forEach(function (modifier) {
			if (modifier['function']) {
			// eslint-disable-line dot-notation
			console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
			}
			var fn = modifier['function'] \|\| modifier.fn; // eslint-disable-line dot-notation
			if (modifier.enabled && isFunction(fn)) {
			// Add properties to offsets to make them a complete clientRect object
			// we do this before each modifier to make sure the previous one doesn't
			// mess with these values
			data.offsets.popper = getClientRect(data.offsets.popper);
			data.offsets.reference = getClientRect(data.offsets.reference);

			data = fn(data, modifier);
			}
			});

			return data;
			}

			/**
			* Updates the position of the popper, computing the new offsets and applying
			* the new style.<br />
			* Prefer `scheduleUpdate` over `update` because of performance reasons.
			* @method
			* @memberof Popper
			*/
			function update() {
			// if popper is destroyed, don't perform any further update
			if (this.state.isDestroyed) {
			return;
			}

			var data = {
			instance: this,
			styles: {},
			arrowStyles: {},
			attributes: {},
			flipped: false,
			offsets: {}
			};

			// compute reference element offsets
			data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);

			// compute auto placement, store placement inside the data object,
			// modifiers will be able to edit `placement` if needed
			// and refer to originalPlacement to know the original value
			data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);

			// store the computed placement inside `originalPlacement`
			data.originalPlacement = data.placement;

			data.positionFixed = this.options.positionFixed;

			// compute the popper offsets
			data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);

			data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';

			// run the modifiers
			data = runModifiers(this.modifiers, data);

			// the first `update` will call `onCreate` callback
			// the other ones will call `onUpdate` callback
			if (!this.state.isCreated) {
			this.state.isCreated = true;
			this.options.onCreate(data);
			} else {
			this.options.onUpdate(data);
			}
			}

			/**
			* Helper used to know if the given modifier is enabled.
			* @method
			* @memberof Popper.Utils
			* @returns {Boolean}
			*/
			function isModifierEnabled(modifiers, modifierName) {
			return modifiers.some(function (_ref) {
			var name = _ref.name,
			enabled = _ref.enabled;
			return enabled && name === modifierName;
			});
			}

			/**
			* Get the prefixed supported property name
			* @method
			* @memberof Popper.Utils
			* @argument {String} property (camelCase)
			* @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
			*/
			function getSupportedPropertyName(property) {
			var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
			var upperProp = property.charAt(0).toUpperCase() + property.slice(1);

			for (var i = 0; i < prefixes.length; i++) {
			var prefix = prefixes[i];
			var toCheck = prefix ? '' + prefix + upperProp : property;
			if (typeof document.body.style[toCheck] !== 'undefined') {
			return toCheck;
			}
			}
			return null;
			}

			/**
			* Destroys the popper.
			* @method
			* @memberof Popper
			*/
			function destroy() {
			this.state.isDestroyed = true;

			// touch DOM only if `applyStyle` modifier is enabled
			if (isModifierEnabled(this.modifiers, 'applyStyle')) {
			this.popper.removeAttribute('x-placement');
			this.popper.style.position = '';
			this.popper.style.top = '';
			this.popper.style.left = '';
			this.popper.style.right = '';
			this.popper.style.bottom = '';
			this.popper.style.willChange = '';
			this.popper.style[getSupportedPropertyName('transform')] = '';
			}

			this.disableEventListeners();

			// remove the popper if user explicity asked for the deletion on destroy
			// do not use `remove` because IE11 doesn't support it
			if (this.options.removeOnDestroy) {
			this.popper.parentNode.removeChild(this.popper);
			}
			return this;
			}

			/**
			* Get the window associated with the element
			* @argument {Element} element
			* @returns {Window}
			*/
			function getWindow(element) {
			var ownerDocument = element.ownerDocument;
			return ownerDocument ? ownerDocument.defaultView : window;
			}

			function attachToScrollParents(scrollParent, event, callback, scrollParents) {
			var isBody = scrollParent.nodeName === 'BODY';
			var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
			target.addEventListener(event, callback, { passive: true });

			if (!isBody) {
			attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
			}
			scrollParents.push(target);
			}

			/**
			* Setup needed event listeners used to update the popper position
			* @method
			* @memberof Popper.Utils
			* @private
			*/
			function setupEventListeners(reference, options, state, updateBound) {
			// Resize event listener on window
			state.updateBound = updateBound;
			getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });

			// Scroll event listener on scroll parents
			var scrollElement = getScrollParent(reference);
			attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
			state.scrollElement = scrollElement;
			state.eventsEnabled =

flamenco-manager/static/bootstrap/js/bootstrap.bundle.jsb6f6d5dd2e9fmaster

bootstrap.bundle.jsView Options

flamenco-manager/static/bootstrap/js/bootstrap.bundle.js
b6f6d5dd2e9fmaster

bootstrap.bundle.js
View Options