https://www.eurotops.nl/out/eurotops_responsive/src/js/scripts.min.js?1789983148

1!function(e){var t=!0;e.flexslider=function(a,n){var i=e(a);i.vars=e.extend({},e.flexslider.defaults,n);var s,r=i.vars.namespace,o=window.navigator&&window.navigator.msPointerEnabled&&window.MSGesture,l=("ontouchstart"in window||o||window.DocumentTouch&&document instanceof DocumentTouch)&&i.vars.touch,c="click touchend MSPointerUp keyup",d="",u="vertical"===i.vars.direction,v=i.vars.reverse,p=i.vars.itemWidth>0,m="fade"===i.vars.animation,f=""!==i.vars.asNavFor,g={};e.data(a,"flexslider",i),g={init:function(){i.animating=!1,i.currentSlide=parseInt(i.vars.startAt?i.vars.startAt:0,10),isNaN(i.currentSlide)&&(i.currentSlide=0),i.animatingTo=i.currentSlide,i.atEnd=0===i.currentSlide||i.currentSlide===i.last,i.containerSelector=i.vars.selector.substr(0,i.vars.selector.search(" ")),i.slides=e(i.vars.selector,i),i.container=e(i.containerSelector,i),i.count=i.slides.length,i.syncExists=e(i.vars.sync).length>0,"slide"===i.vars.animation&&(i.vars.animation="swing"),i.prop=u?"top":"marginLeft",i.args={},i.manualPause=!1,i.stopped=!1,i.started=!1,i.startTimeout=null,i.transitions=!i.vars.video&&!m&&i.vars.useCSS&&function(){var e=document.createElement("div"),t=["perspectiveProperty","WebkitPerspective","MozPerspective","OPerspective","msPerspective"];for(var a in t)if(void 0!==e.style[t[a]])return i.pfx=t[a].replace("Perspective","").toLowerCase(),i.prop="-"+i.pfx+"-transform",!0;return!1}(),i.ensureAnimationEnd="",""!==i.vars.controlsContainer&&(i.controlsContainer=e(i.vars.controlsContainer).length>

1,set:function(){var t="thumbnails"===i.vars.controlNav?"img":"a";i.controlNav=e("."+r+"control-nav li "+t,i.controlsContainer?i.controlsContainer:i)},active:function(){i.controlNav.removeClass(r+"active").eq(i.animatingTo).addClass(r+"active")},update:function(t,a){i.pagingCount>1&&"add"===t?i.controlNavScaffold.append(e('<li><a href="#">'+i.count+"</a></li>")):1===i.pagingCount?i.controlNavScaffold.find("li").remove():i.controlNav.eq(a).closest("li").remove(),g.controlNav.set(),i.pagingCount>1&&i.pagingCount!==i.controlNav.length?i.update(a,t):g.controlNav.active()}},directionNav:{setup:function(){var t=e('<ul class="'+r+'direction-nav"><li class="'+r+'nav-prev"><a class="'+r+'prev" href="#">'+i.vars.prevText+'</a></li><li class="'+r+'nav-next"><a class="'+r+'next" href="#">'+i.vars.nextText+"</a></li></ul>");i.customDirectionNav?i.directionNav=i.customDirectionNav:i.controlsContainer?(e(i.controlsContainer).append(t),i.directionNav=e("."+r+"direction-nav li a",i.controlsContainer)):(i.append(t),i.directionNav=e("."+r+"direction-nav li a",i)),g.directionNav.update(),i.directionNav.bind(c,function(t){var a;t.preventDefault(),""!==d&&d!==t.type||(a=e(this).hasClass(r+"next")?i.getTarget("next"):i.getTarget("prev"),i.flexAnimate(a,i.vars.pauseOnAction)),""===d&&(d=t.type),g.setToClearWatchedEvent()})},update:function(){var e=r+"disabled";1===i.pagingCount?i.directionNav.addClass(e).attr("tabindex","-1"):i.vars.animationLoop?i.directionNav.removeClass(e).removeAttr("tabindex"):0===i.animatingTo?i.directionNav.removeClass(e).filter("."+r+"prev").addClass(e).attr("tabindex","-1"):i.animatingTo===i.last?i.directionNav.removeClass(e).filter("."+r+"next").addClass(e).attr("tabindex","-1"):i.directionNav.removeClass(e).removeAttr("tabindex")}},pausePlay:{setup:function(){var t=e('<div class="'+r+'pauseplay"><a href="#"></a></div>');i.controlsContainer?(i.controlsContainer.append(t),i.pausePlay=e("."+r+"pauseplay a",i.controlsContainer)):(i.append(t),i.pausePlay=e("."+r+"pauseplay a",i)),g.pausePlay.update(i.vars.slideshow?r+"pause":r+"play"),i.pausePlay.bind(c,function(t){t.preventDefault(),""!==d&&d!==t.type||(e(this).hasClass(r+"pause")?(i.manualPause=!0,i.manualPlay=!1,i.pause()):(i.manualPause=!1,i.manualPlay=!0,i.play())),""===d&&(d=t.type),g.setToClearWatchedEvent()})},update:function(e){"play"===e?i.pausePlay.removeClass(r+"pause").addClass(r+"play").html(i.vars.playText):i.pausePlay.removeClass(r+"play").addClass(r+"pause").html(i.vars.pauseText)}},touch:function(){var e,t,n,s,r,l,c,d,f,g=!1,h=0,S=0,x=0;if(o){a.style.msTouchAction="none",a._gesture=new MSGesture,a._gesture.target=a,a.addEventListener("MSPointerDown",function(e){e.stopPropagation(),i.animating?e.preventDefault():(i.pause(),a._gesture.addPointer(e.pointerId),x=0,s=u?i.h:i.w,l=Number(new Date),n=p&&v&&i.animatingTo===i.last?0:p&&v?i.limit-(i.itemW+i.vars.itemMargin)*i.move*i.animatingTo:p&&i.currentSlide===i.last?i.limit:p?(i.itemW+i.vars.itemMargin)*i.move*i.currentSlide:v?(i.last-i.currentSlide+i.cloneOffset)*s:(i.currentSlide+i.cloneOffset)*s)},!1),a._slider=i,a.addEventListener("MSGestureChange",function(e){e.stopPropagation();var t=e.target._slider;if(!t)return;var i=-e.translationX,o=-e.translationY;if(r=x+=u?o:i,g=u?Math.abs(x)<Math.abs(-i):Math.abs(x)<Math.abs(-o),e.detail===e.MSGESTURE_FLAG_INERTIA)return void setImmediate(function(){a._gesture.stop()});(!g||Number(new Date)-l>500)&&(e.preventDefault(),!m&&t.transitions&&(t.vars.animationLoop||(r=x/(0===t.currentSlide&&x<0||t.currentSlide===t.last&&x>0?Math.abs(x)/s+2:1)),t.setProps(n+r,"setTouch")))},!1),a.addEventListener("MSGestureEnd",function(a){a.stopPropagation();var i=a.target._slider;if(!i)return;if(i.animatingTo===i.currentSlide&&!g&&null!==r){var o=v?-r:r,c=o>0?i.getTarget("next"):i.getTarget("prev");i.canAdvance(c)&&(Number(new Date)-l<550&&Math.abs(o)>50||Math.abs(o)>s/2)?i.flexAnimate(c,i.vars.pauseOnAction):m||i.flexAnimate(i.currentSlide,i.vars.pauseOnAction,!0)}e=null,t=null,r=null,n=null,x=0},!1)}else c=function(r){i.animating?r.preventDefault():(window.navigator.msPointerEnabled||1===r.touches.length)&&(i.pause(),s=u?i.h:i.w,l=Number(new Date),h=r.touches[0].pageX,S=r.touches[0].pageY,n=p&&v&&i.animatingTo===i.last?0:p&&v?i.limit-(i.itemW+i.vars.itemMargin)*i.move*i.animatingTo:p&&i.currentSlide===i.last?i.limit:p?(i.itemW+i.vars.itemMargin)*i.move*i.currentSlide:v?(i.last-i.currentSlide+i.cloneOffset)*s:(i.currentSlide+i.cloneOffset)*s,e=u?S:h,t=u?h:S,a.addEventListener("touchmove",d,!1),a.addEventListener("touchend",f,!1))},d=function(a){h=a.touches[0].pageX,S=a.touches[0].pageY,r=u?e-S:e-h;(!(g=u?Math.abs(r)<Math.abs(h-t):Math.abs(r)<Math.abs(S-t))||Number(new Date)-l>500)&&(a.preventDefault(),!m&&i.transitions&&(i.vars.animationLoop||(r/=0===i.currentSlide&&r<0||i.currentSlide===i.last&&r>0?Math.abs(r)/s+2:1),i.setProps(n+r,"setTouch")))},f=function(o){if(a.removeEventListener("touchmove",d,!1),i.animatingTo===i.currentSlide&&!g&&null!==r){var c=v?-r:r,u=c>0?i.getTarget("next"):i.getTarget("prev");i.canAdvance(u)&&(Number(new Date)-l<550&&Math.abs(c)>50||Math.abs(c)>s/2)?i.flexAnimate(u,i.vars.pauseOnAction):m||i.flexAnimate(i.currentSlide,i.vars.pauseOnAction,!0)}a.removeEventListener("touchend",f,!1),e=null,t=null,r=null,n=null},a.addEventListener("touchstart",c,!1)},resize:function(){!i.animating&&i.is(":visible")&&(p||i.doMath(),m?g.smoothHeight():p?(i.slides.width(i.computedW),i.update(i.pagingCount),i.setProps()):u?(i.viewport.height(i.h),i.setProps(i.h,"setTotal")):(i.vars.smoothHeight&&g.smoothHeight(),i.newSlides.width(i.computedW),i.setProps(i.computedW,"setTotal")))},smoothHeight:function(e){if(!u||m){var t=m?i:i.viewport;e?t.animate({height:i.slides.eq(i.animatingTo).height()},e):t.height(i.slides.eq(i.animatingTo).height())}},sync:function(t){var a=e(i.vars.sync).data("flexslider"),n=i.animatingTo;switch(t){case"animate":a.flexAnimate(n,i.vars.pauseOnAction,!1,!0);break;case"play":a.playing||a.asNav||a.play();break;case"pause":a.pause()}},uniqueID:function(t){return t.filter("[id]").add(t.find("[id]")).each(function(){var t=e(this);t.attr("id",t.attr("id")+"_clone")}),t},pauseInvisible:{visProp:null,init:function(){var e=g.pauseInvisible.getHiddenProp();if(e){var t=e.replace(/[H|h]idden/,"")+"visibilitychange";document.addEventListener(t,function(){g.pauseInvisible.isHidden()?i.startTimeout?clearTimeout(i.startTimeout):i.pause():i.started?i.play():i.vars.initDelay>0?setTimeout(i.play,i.vars.initDelay):i.play()})}},isHidden:function(){var e=g.pauseInvisible.getHiddenProp();return!!e&&document[e]},getHiddenProp:function(){var e=["webkit","moz","ms","o"];if("hidden"in document)return"hidden";for(var t=0;t<e.length;t++)if(e[t]+"Hidden"in document)return e[t]+"Hidden";return null}},setToClearWatchedEvent:function(){clearTimeout(s),s=setTimeout(function(){d=""},3e3)}},i.flexAnimate=function(t,a,n,s,o){if(i.vars.animationLoop||t===i.currentSlide||(i.direction=t>i.currentSlide?"next":"prev"),f&&1===i.pagingCount&&(i.direction=i.currentItem<t?"next":"prev"),!i.animating&&(i.canAdvance(t,o)||n)&&i.is(":visible")){if(f&&s){var c=e(i.vars.asNavFor).data("flexslider");if(i.atEnd=0===t||t===i.count-1,c.flexAnimate(t,!0,!1,!0,o),i.direction=i.currentItem<t?"next":"prev",c.direction=i.direction,Math.ceil((t+1)/i.visible)-1===i.currentSlide||0===t)return i.currentItem=t,i.slides.removeClass(r+"active-slide").eq(t).addClass(r+"active-slide"),!1;i.currentItem=t,i.slides.removeClass(r+"active-slide").eq(t).addClass(r+"active-slide"),t=Math.floor(t/i.visible)}if(i.animating=!0,i.animatingTo=t,a&&i.pause(),i.vars.before(i),i.syncExists&&!o&&g.sync("animate"),i.vars.controlNav&&g.controlNav.active(),p||i.slides.removeClass(r+"active-slide").eq(t).addClass(r+"active-slide"),i.atEnd=0===t||t===i.last,i.vars.directionNav&&g.directionNav.update(),t===i.last&&(i.vars.end(i),i.vars.animationLoop||i.pause()),m)l?(i.slides.eq(i.currentSlide).css({opacity:0,zIndex:1}),i.slides.eq(t).css({opacity:1,zIndex:2}),i.wrapup(x)):(i.slides.eq(i.currentSlide).css({zIndex:1}).animate({opacity:0},i.vars.animationSpeed,i.vars.easing),i.slides.eq(t).css({zIndex:2}).animate({opacity:1},i.vars.animationSpeed,i.vars.easing,i.wrapup));else{var d,h,S,x=u?i.slides.filter(":first").height():i.computedW;p?(d=i.vars.itemMargin,h=(S=(i.itemW+d)*i.move*i.animatingTo)>i.limit&&1!==i.visible?i.limit:S):h=0===i.currentSlide&&t===i.count-1&&i.vars.animationLoop&&"next"!==i.direction?v?(i.count+i.cloneOffset)*x:0:i.currentSlide===i.last&&0===t&&i.vars.animationLoop&&"prev"!==i.direction?v?0:(i.count+1)*x:v?(i.count-1-t+i.cloneOffset)*x:(t+i.cloneOffset)*x,i.setProps(h,"",i.vars.animationSpeed),i.transitions?(i.vars.animationLoop&&i.atEnd||(i.animating=!1,i.currentSlide=i.animatingTo),i.container.unbind("webkitTransitionEnd transitionend"),i.container.bind("webkitTransitionEnd transitionend",function(){clearTimeout(i.ensureAnimationEnd),i.wrapup(x)}),clearTimeout(i.ensureAnimationEnd),i.ensureAnimationEnd=setTimeout(function(){i.wrapup(x)},i.vars.animationSpeed+100)):i.container.animate(i.args,i.vars.animationSpeed,i.vars.easing,function(){i.wrapup(x)})}i.vars.smoothHeight&&g.smoothHeight(i.vars.animationSpeed)}},i.wrapup=function(e){m||p||(0===i.currentSlide&&i.animatingTo===i.last&&i.vars.animationLoop?i.setProps(e,"jumpEnd"):i.currentSlide===i.last&&0===i.animatingTo&&i.vars.animationLoop&&i.setProps(e,"jumpStart")),i.animating=!1,i.currentSlide=i.animatingTo,i.vars.after(i)},i.animateSlides=function(){!i.animating&&t&&i.flexAnimate(i.getTarget("next"))},i.pause=function(){clearInterval(i.animatedSlides),i.animatedSlides=null,i.playing=!1,i.vars.pausePlay&&g.pausePlay.update("play"),i.syncExists&&g.sync("pause")},i.play=function(){i.playing&&clearInterval(i.animatedSlides),i.animatedSlides=i.animatedSlides||setInterval(i.animateSlides,i.vars.slideshowSpeed),i.started=i.playing=!0,i.vars.pausePlay&&g.pausePlay.update("pause"),i.syncExists&&g.sync("play")},i.stop=function(){i.pause(),i.stopped=!0},i.canAdvance=function(e,t){var a=f?i.pagingCount-1:i.last;return!!t||(!(!f||i.currentItem!==i.count-1||0!==e||"prev"!==i.direction)||(!f||0!==i.currentItem||e!==i.pagingCount-1||"next"===i.direction)&&(!(e===i.currentSlide&&!f)&&(!!i.vars.animationLoop||(!i.atEnd||0!==i.currentSlide||e!==a||"next"===i.direction)&&(!i.atEnd||i.currentSlide!==a||0!==e||"next"!==i.direction))))},i.getTarget=function(e){return i.direction=e,"next"===e?i.currentSlide===i.last?0:i.currentSlide+1:0===i.currentSlide?i.last:i.currentSlide-1},i.setProps=function(e,t,a){var n,s=(n=e||(i.itemW+i.vars.itemMargin)*i.move*i.animatingTo,-1*function(){if(p)return"setTouch"===t?e:v&&i.animatingTo===i.last?0:v?i.limit-(i.itemW+i.vars.itemMargin)*i.move*i.animatingTo:i.animatingTo===i.last?i.limit:n;switch(t){case"setTotal":return v?(i.count-1-i.currentSlide+i.cloneOffset)*e:(i.currentSlide+i.cloneOffset)*e;case"setTouch":return e;case"jumpEnd":return v?e:i.count*e;case"jumpStart":return v?i.count*e:e;default:return e}}()+"px");i.transitions&&(s=u?"translate3d(0,"+s+",0)":"translate3d("+s+",0,0)",a=void 0!==a?a/1e3+"s":"0s",i.container.css("-"+i.pfx+"-transition-duration",a),i.container.css("transition-duration",a)),i.args[i.prop]=s,(i.transitions||void 0===a)&&i.container.css(i.args),i.container.css("transform",s)},i.setup=function(t){var a,n;m?(i.slides.css({width:"100%",float:"left",marginRight:"-100%",position:"relative"}),"init"===t&&(l?i.slides.css({opacity:0,display:"block",webkitTransition:"opacity "+i.vars.animationSpeed/1e3+"s ease",zIndex:1}).eq(i.currentSlide).css({opacity:1,zIndex:2}):0==i.vars.fadeFirstSlide?i.slides.css({opacity:0,display:"block",zIndex:1}).eq(i.currentSlide).css({zIndex:2}).css({opacity:1}):i.slides.css({opacity:0,display:"block",zIndex:1}).eq(i.currentSlide).css({zIndex:2}).animate({opacity:1},i.vars.animationSpeed,i.vars.easing)),i.vars.smoothHeight&&g.smoothHeight()):("init"===t&&(i.viewport=e('<div class="'+r+'viewport"></div>').css({overflow:"hidden",position:"relative"}).appendTo(i).append(i.container),i.cloneCount=0,i.cloneOffset=0,v&&(n=e.makeArray(i.slides).reverse(),i.slides=e(n),i.container.empty().append(i.slides))),i.vars.animationLoop&&!p&&(i.cloneCount=2,i.cloneOffset=1,"init"!==t&&i.container.find(".clone").remove(),i.container.append(g.uniqueID(i.slides.first().clone().addClass("clone")).attr("aria-hidden","true")).prepend(g.uniqueID(i.slides.last().clone().addClass("clone")).attr("aria-hidden","true"))),i.newSlides=e(i.vars.selector,i),a=v?i.c

5
6(function (global, factory) {
7  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
8  typeof define === 'function' && define.amd ? define(factory) :
9  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.bootstrap = factory());
10})(this, (function () { 'use strict';
11
12  /**
13   * --------------------------------------------------------------------------
14   * Bootstrap dom/data.js
15   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
16   * --------------------------------------------------------------------------
17   */
18
19  /**
20   * Constants
21   */
22
23  const elementMap = new Map();
24  const Data = {
25    set(element, key, instance) {
26      if (!elementMap.has(element)) {
27        elementMap.set(element, new Map());
28      }
29      const instanceMap = elementMap.get(element);
30
31      // make it clear we only want one instance per element
32      // can be removed later when multiple key/instances are fine to be used
33      if (!instanceMap.has(key) && instanceMap.size !== 0) {
34        // eslint-disable-next-line no-console
35        console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);
36        return;
37      }
38      instanceMap.set(key, instance);
39    },
40    get(element, key) {
41      if (elementMap.has(element)) {
42        return elementMap.get(element).get(key) || null;
43      }
44      return null;
45    },
46    remove(element, key) {
47      if (!elementMap.has(element)) {
48        return;
49      }
50      const instanceMap = elementMap.get(element);
51      instanceMap.delete(key);
52
53      // free up element references if there are no instances left for an element
54      if (instanceMap.size === 0) {
55        elementMap.delete(element);
56      }
57    }
58  };
59
60  /**
61   * --------------------------------------------------------------------------
62   * Bootstrap util/index.js
63   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
64   * --------------------------------------------------------------------------
65   */
66
67  const MAX_UID = 1000000;
68  const MILLISECONDS_MULTIPLIER = 1000;
69  const TRANSITION_END = 'transitionend';
70
71  /**
72   * Properly escape IDs selectors to handle weird IDs
73   * @param {string} selector
74   * @returns {string}
75   */
76  const parseSelector = selector => {
77    if (selector && window.CSS && window.CSS.escape) {
78      // document.querySelector needs escaping to handle IDs (html5+) containing for instance /
79      selector = selector.replace(/#([^\s"#']+)/g, (match, id) => `#${CSS.escape(id)}`);
80    }
81    return selector;
82  };
83
84  // Shout-out Angus Croll (https://goo.gl/pxwQGp)
85  const toType = object => {
86    if (object === null || object === undefined) {
87      return `${object}`;
88    }
89    return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase();
90  };
91
92  /**
93   * Public Util API
94   */
95
96  const getUID = prefix => {
97    do {
98      prefix += Math.floor(Math.random() * MAX_UID);
99    } while (document.getElementById(prefix));
100    return prefix;
101  };
102  const getTransitionDurationFromElement = element => {
103    if (!element) {
104      return 0;
105    }
106
107    // Get transition-duration of the element
108    let {
109      transitionDuration,
110      transitionDelay
111    } = window.getComputedStyle(element);
112    const floatTransitionDuration = Number.parseFloat(transitionDuration);
113    const floatTransitionDelay = Number.parseFloat(transitionDelay);
114
115    // Return 0 if element or transition duration is not found
116    if (!floatTransitionDuration && !floatTransitionDelay) {
117      return 0;
118    }
119
120    // If multiple durations are defined, take the first
121    transitionDuration = transitionDuration.split(',')[0];
122    transitionDelay = transitionDelay.split(',')[0];
123    return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
124  };
125  const triggerTransitionEnd = element => {
126    element.dispatchEvent(new Event(TRANSITION_END));
127  };
128  const isElement$1 = object => {
129    if (!object || typeof object !== 'object') {
130      return false;
131    }
132    if (typeof object.jquery !== 'undefined') {
133      object = object[0];
134    }
135    return typeof object.nodeType !== 'undefined';
136  };
137  const getElement = object => {
138    // it's a jQuery object or a node element
139    if (isElement$1(object)) {
140      return object.jquery ? object[0] : object;
141    }
142    if (typeof object === 'string' && object.length > 0) {
143      return document.querySelector(parseSelector(object));
144    }
145    return null;
146  };
147  const isVisible = element => {
148    if (!isElement$1(element) || element.getClientRects().length === 0) {
149      return false;
150    }
151    const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible';
152    // Handle `details` element as its content may falsie appear visible when it is closed
153    const closedDetails = element.closest('details:not([open])');
154    if (!closedDetails) {
155      return elementIsVisible;
156    }
157    if (closedDetails !== element) {
158      const summary = element.closest('summary');
159      if (summary && summary.parentNode !== closedDetails) {
160        return false;
161      }
162      if (summary === null) {
163        return false;
164      }
165    }
166    return elementIsVisible;
167  };
168  const isDisabled = element => {
169    if (!element || element.nodeType !== Node.ELEMENT_NODE) {
170      return true;
171    }
172    if (element.classList.contains('disabled')) {
173      return true;
174    }
175    if (typeof element.disabled !== 'undefined') {
176      return element.disabled;
177    }
178    return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
179  };
180  const findShadowRoot = element => {
181    if (!document.documentElement.attachShadow) {
182      return null;
183    }
184
185    // Can find the shadow root otherwise it'll return the document
186    if (typeof element.getRootNode === 'function') {
187      const root = element.getRootNode();
188      return root instanceof ShadowRoot ? root : null;
189    }
190    if (element instanceof ShadowRoot) {
191      return element;
192    }
193
194    // when we don't find a shadow root
195    if (!element.parentNode) {
196      return null;
197    }
198    return findShadowRoot(element.parentNode);
199  };
200  const noop = () => {};
201
202  /**
203   * Trick to restart an element's animation
204   *
205   * @param {HTMLElement} element
206   * @return void
207   *
208   * @see https://www.harrytheo.com/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
209   */
210  const reflow = element => {
211    element.offsetHeight; // eslint-disable-line no-unused-expressions
212  };
213  const getjQuery = () => {
214    if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
215      return window.jQuery;
216    }
217    return null;
218  };
219  const DOMContentLoadedCallbacks = [];
220  const onDOMContentLoaded = callback => {
221    if (document.readyState === 'loading') {
222      // add listener on the first call when the document is in loading state
223      if (!DOMContentLoadedCallbacks.length) {
224        document.addEventListener('DOMContentLoaded', () => {
225          for (const callback of DOMContentLoadedCallbacks) {
226            callback();
227          }
228        });
229      }
230      DOMContentLoadedCallbacks.push(callback);
231    } else {
232      callback();
233    }
234  };
235  const isRTL = () => document.documentElement.dir === 'rtl';
236  const defineJQueryPlugin = plugin => {
237    onDOMContentLoaded(() => {
238      const $ = getjQuery();
239      /* istanbul ignore if */
240      if ($) {
241        const name = plugin.NAME;
242        const JQUERY_NO_CONFLICT = $.fn[name];
243        $.fn[name] = plugin.jQueryInterface;
244        $.fn[name].Constructor = plugin;
245        $.fn[name].noConflict = () => {
246          $.fn[name] = JQUERY_NO_CONFLICT;
247          return plugin.jQueryInterface;
248        };
249      }
250    });
251  };
252  const execute = (possibleCallback, args = [], defaultValue = possibleCallback) => {
253    return typeof possibleCallback === 'function' ? possibleCallback.call(...args) : defaultValue;
254  };
255  const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
256    if (!waitForTransition) {
257      execute(callback);
258      return;
259    }
260    const durationPadding = 5;
261    const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;

262    let called = false;
263    const handler = ({
264      target
265    }) => {
266      if (target !== transitionElement) {
267        return;
268      }
269      called = true;
270      transitionElement.removeEventListener(TRANSITION_END, handler);
271      execute(callback);
272    };
273    transitionElement.addEventListener(TRANSITION_END, handler);
274    setTimeout(() => {
275      if (!called) {
276        triggerTransitionEnd(transitionElement);
277      }
278    }, emulatedDuration);
279  };
280
281  /**
282   * Return the previous/next element of a list.
283   *
284   * @param {array} list    The list of elements
285   * @param activeElement   The active element
286   * @param shouldGetNext   Choose to get next or previous element
287   * @param isCycleAllowed
288   * @return {Element|elem} The proper element
289   */
290  const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
291    const listLength = list.length;
292    let index = list.indexOf(activeElement);
293
294    // if the element does not exist in the list return an element
295    // depending on the direction and if cycle is allowed
296    if (index === -1) {
297      return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];
298    }
299    index += shouldGetNext ? 1 : -1;
300    if (isCycleAllowed) {
301      index = (index + listLength) % listLength;
302    }
303    return list[Math.max(0, Math.min(index, listLength - 1))];
304  };
305
306  /**
307   * --------------------------------------------------------------------------
308   * Bootstrap dom/event-handler.js
309   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
310   * --------------------------------------------------------------------------
311   */
312
313
314  /**
315   * Constants
316   */
317
318  const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
319  const stripNameRegex = /\..*/;
320  const stripUidRegex = /::\d+$/;
321  const eventRegistry = {}; // Events storage
322  let uidEvent = 1;
323  const customEvents = {
324    mouseenter: 'mouseover',
325    mouseleave: 'mouseout'
326  };
327  const nativeEvents = new Set(['click', 'dblclick', 'mouseup', 'mousedown', 'contextmenu', 'mousewheel', 'DOMMouseScroll', 'mouseover', 'mouseout', 'mousemove', 'selectstart', 'selectend', 'keydown', 'keypress', 'keyup', 'orientationchange', 'touchstart', 'touchmove', 'touchend', 'touchcancel', 'pointerdown', 'pointermove', 'pointerup', 'pointerleave', 'pointercancel', 'gesturestart', 'gesturechange', 'gestureend', 'focus', 'blur', 'change', 'reset', 'select', 'submit', 'focusin', 'focusout', 'load', 'unload', 'beforeunload', 'resize', 'move', 'DOMContentLoaded', 'readystatechange', 'error', 'abort', 'scroll']);
328
329  /**
330   * Private methods
331   */
332
333  function makeEventUid(element, uid) {
334    return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
335  }
336  function getElementEvents(element) {
337    const uid = makeEventUid(element);
338    element.uidEvent = uid;
339    eventRegistry[uid] = eventRegistry[uid] || {};
340    return eventRegistry[uid];
341  }
342  function bootstrapHandler(element, fn) {
343    return function handler(event) {
344      hydrateObj(event, {
345        delegateTarget: element
346      });
347      if (handler.oneOff) {
348        EventHandler.off(element, event.type, fn);
349      }
350      return fn.apply(element, [event]);
351    };
352  }
353  function bootstrapDelegationHandler(element, selector, fn) {
354    return function handler(event) {
355      const domElements = element.querySelectorAll(selector);
356      for (let {
357        target
358      } = event; target && target !== this; target = target.parentNode) {
359        for (const domElement of domElements) {
360          if (domElement !== target) {
361            continue;
362          }
363          hydrateObj(event, {
364            delegateTarget: target
365          });
366          if (handler.oneOff) {
367            EventHandler.off(element, event.type, selector, fn);
368          }
369          return fn.apply(target, [event]);
370        }
371      }
372    };
373  }
374  function findHandler(events, callable, delegationSelector = null) {
375    return Object.values(events).find(event => event.callable === callable && event.delegationSelector === delegationSelector);
376  }
377  function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
378    const isDelegated = typeof handler === 'string';
379    // TODO: tooltip passes `false` instead of selector, so we need to check
380    const callable = isDelegated ? delegationFunction : handler || delegationFunction;
381    let typeEvent = getTypeEvent(originalTypeEvent);
382    if (!nativeEvents.has(typeEvent)) {
383      typeEvent = originalTypeEvent;
384    }
385    return [isDelegated, callable, typeEvent];
386  }
387  function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
388    if (typeof originalTypeEvent !== 'string' || !element) {
389      return;
390    }
391    let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
392
393    // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
394    // this prevents the handler from being dispatched the same way as mouseover or mouseout does
395    if (originalTypeEvent in customEvents) {
396      const wrapFunction = fn => {
397        return function (event) {
398          if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
399            return fn.call(this, event);
400          }
401        };
402      };
403      callable = wrapFunction(callable);
404    }
405    const events = getElementEvents(element);
406    const handlers = events[typeEvent] || (events[typeEvent] = {});
407    const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
408    if (previousFunction) {
409      previousFunction.oneOff = previousFunction.oneOff && oneOff;
410      return;
411    }
412    const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''));
413    const fn = isDelegated ? bootstrapDelegationHandler(element, handler, callable) : bootstrapHandler(element, callable);
414    fn.delegationSelector = isDelegated ? handler : null;
415    fn.callable = callable;
416    fn.oneOff = oneOff;
417    fn.uidEvent = uid;
418    handlers[uid] = fn;
419    element.addEventListener(typeEvent, fn, isDelegated);
420  }
421  function removeHandler(element, events, typeEvent, handler, delegationSelector) {
422    const fn = findHandler(events[typeEvent], handler, delegationSelector);
423    if (!fn) {
424      return;
425    }
426    element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
427    delete events[typeEvent][fn.uidEvent];
428  }
429  function removeNamespacedHandlers(element, events, typeEvent, namespace) {
430    const storeElementEvent = events[typeEvent] || {};
431    for (const [handlerKey, event] of Object.entries(storeElementEvent)) {
432      if (handlerKey.includes(namespace)) {
433        removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
434      }
435    }
436  }
437  function getTypeEvent(event) {
438    // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
439    event = event.replace(stripNameRegex, '');
440    return customEvents[event] || event;
441  }
442  const EventHandler = {
443    on(element, event, handler, delegationFunction) {
444      addHandler(element, event, handler, delegationFunction, false);
445    },
446    one(element, event, handler, delegationFunction) {
447      addHandler(element, event, handler, delegationFunction, true);
448    },
449    off(element, originalTypeEvent, handler, delegationFunction) {
450      if (typeof originalTypeEvent !== 'string' || !element) {
451        return;
452      }
453      const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
454      const inNamespace = typeEvent !== originalTypeEvent;
455      const events = getElementEvents(element);
456      const storeElementEvent = events[typeEvent] || {};
457      const isNamespace = originalTypeEvent.startsWith('.');
458      if (typeof callable !== 'undefined') {
459        // Simplest case: handler is passed, remove that listener ONLY.
460        if (!Object.keys(storeElementEvent).length) {
461          return;
462        }
463        removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
464        return;
465      }
466      if (isNamespace) {
467        for (const elementEvent of Object.keys(events)) {
468          removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
469        }
470      }
471      for (const [keyHandlers, event] of Object.entries(storeElementEvent)) {
472        const handlerKey = keyHandlers.replace(stripUidRegex, '');
473        if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
474          removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
475        }
476      }
477    },
478    trigger(element, event, args) {
479      if (typeof event !== 'string' || !element) {
480        return null;
481      }
482      const $ = getjQuery();
483      const typeEvent = getTypeEvent(event);
484      const inNamespace = event !== typeEvent;
485      let jQueryEvent = null;
486      let bubbles = true;
487      let nativeDispatch = true;
488      let defaultPrevented = false;
489      if (inNamespace && $) {
490        jQueryEvent = $.Event(event, args);
491        $(element).trigger(jQueryEvent);
492        bubbles = !jQueryEvent.isPropagationStopped();
493        nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
494        defaultPrevented = jQueryEvent.isDefaultPrevented();
495      }
496      const evt = hydrateObj(new Event(event, {
497        bubbles,
498        cancelable: true
499      }), args);
500      if (defaultPrevented) {
501        evt.preventDefault();
502      }
503      if (nativeDispatch) {
504        element.dispatchEvent(evt);
505      }
506      if (evt.defaultPrevented && jQueryEvent) {
507        jQueryEvent.preventDefault();
508      }
509      return evt;
510    }
511  };
512  function hydrateObj(obj, meta = {}) {
513    for (const [key, value] of Object.entries(meta)) {

514      try {
515        obj[key] = value;
516      } catch (_unused) {
517        Object.defineProperty(obj, key, {
518          configurable: true,
519          get() {
520            return value;
521          }
522        });
523      }
524    }
525    return obj;
526  }
527
528  /**
529   * --------------------------------------------------------------------------
530   * Bootstrap dom/manipulator.js
531   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
532   * --------------------------------------------------------------------------
533   */
534
535  function normalizeData(value) {
536    if (value === 'true') {
537      return true;
538    }
539    if (value === 'false') {
540      return false;
541    }
542    if (value === Number(value).toString()) {
543      return Number(value);
544    }
545    if (value === '' || value === 'null') {
546      return null;
547    }
548    if (typeof value !== 'string') {
549      return value;
550    }
551    try {
552      return JSON.parse(decodeURIComponent(value));
553    } catch (_unused) {
554      return value;
555    }
556  }
557  function normalizeDataKey(key) {
558    return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`);
559  }
560  const Manipulator = {
561    setDataAttribute(element, key, value) {
562      element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);
563    },
564    removeDataAttribute(element, key) {
565      element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);
566    },
567    getDataAttributes(element) {
568      if (!element) {
569        return {};
570      }
571      const attributes = {};
572      const bsKeys = Object.keys(element.dataset).filter(key => key.startsWith('bs') && !key.startsWith('bsConfig'));
573      for (const key of bsKeys) {
574        let pureKey = key.replace(/^bs/, '');
575        pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1);
576        attributes[pureKey] = normalizeData(element.dataset[key]);
577      }
578      return attributes;
579    },
580    getDataAttribute(element, key) {
581      return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
582    }
583  };
584
585  /**
586   * --------------------------------------------------------------------------
587   * Bootstrap util/config.js
588   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
589   * --------------------------------------------------------------------------
590   */
591
592
593  /**
594   * Class definition
595   */
596
597  class Config {
598    // Getters
599    static get Default() {
600      return {};
601    }
602    static get DefaultType() {
603      return {};
604    }
605    static get NAME() {
606      throw new Error('You have to implement the static method "NAME", for each component!');
607    }
608    _getConfig(config) {
609      config = this._mergeConfigObj(config);
610      config = this._configAfterMerge(config);
611      this._typeCheckConfig(config);
612      return config;
613    }
614    _configAfterMerge(config) {
615      return config;
616    }
617    _mergeConfigObj(config, element) {
618      const jsonConfig = isElement$1(element) ? Manipulator.getDataAttribute(element, 'config') : {}; // try to parse
619
620      return {
621        ...this.constructor.Default,
622        ...(typeof jsonConfig === 'object' ? jsonConfig : {}),
623        ...(isElement$1(element) ? Manipulator.getDataAttributes(element) : {}),
624        ...(typeof config === 'object' ? config : {})
625      };
626    }
627    _typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
628      for (const [property, expectedTypes] of Object.entries(configTypes)) {
629        const value = config[property];
630        const valueType = isElement$1(value) ? 'element' : toType(value);
631        if (!new RegExp(expectedTypes).test(valueType)) {
632          throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`);
633        }
634      }
635    }
636  }
637
638  /**
639   * --------------------------------------------------------------------------
640   * Bootstrap base-component.js
641   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
642   * --------------------------------------------------------------------------
643   */
644
645
646  /**
647   * Constants
648   */
649
650  const VERSION = '5.3.8';
651
652  /**
653   * Class definition
654   */
655
656  class BaseComponent extends Config {
657    constructor(element, config) {
658      super();
659      element = getElement(element);
660      if (!element) {
661        return;
662      }
663      this._element = element;
664      this._config = this._getConfig(config);
665      Data.set(this._element, this.constructor.DATA_KEY, this);
666    }
667
668    // Public
669    dispose() {
670      Data.remove(this._element, this.constructor.DATA_KEY);
671      EventHandler.off(this._element, this.constructor.EVENT_KEY);

672      for (const propertyName of Object.getOwnPropertyNames(this)) {
673        this[propertyName] = null;
674      }
675    }
676
677    // Private
678    _queueCallback(callback, element, isAnimated = true) {
679      executeAfterTransition(callback, element, isAnimated);
680    }
681    _getConfig(config) {
682      config = this._mergeConfigObj(config, this._element);
683      config = this._configAfterMerge(config);
684      this._typeCheckConfig(config);
685      return config;
686    }
687
688    // Static
689    static getInstance(element) {
690      return Data.get(getElement(element), this.DATA_KEY);
691    }
692    static getOrCreateInstance(element, config = {}) {
693      return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);
694    }
695    static get VERSION() {
696      return VERSION;
697    }
698    static get DATA_KEY() {
699      return `bs.${this.NAME}`;
700    }
701    static get EVENT_KEY() {
702      return `.${this.DATA_KEY}`;
703    }
704    static eventName(name) {
705      return `${name}${this.EVENT_KEY}`;
706    }
707  }
708
709  /**
710   * --------------------------------------------------------------------------
711   * Bootstrap dom/selector-engine.js
712   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
713   * --------------------------------------------------------------------------
714   */
715
716  const getSelector = element => {
717    let selector = element.getAttribute('data-bs-target');
718    if (!selector || selector === '#') {
719      let hrefAttribute = element.getAttribute('href');
720
721      // The only valid content that could double as a selector are IDs or classes,
722      // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
723      // `document.querySelector` will rightfully complain it is invalid.
724      // See https://github.com/twbs/bootstrap/issues/32273
725      if (!hrefAttribute || !hrefAttribute.includes('#') && !hrefAttribute.startsWith('.')) {
726        return null;
727      }
728
729      // Just in case some CMS puts out a full URL with the anchor appended
730      if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) {
731        hrefAttribute = `#${hrefAttribute.split('#')[1]}`;
732      }
733      selector = hrefAttribute && hrefAttribute !== '#' ? hrefAttribute.trim() : null;
734    }
735    return selector ? selector.split(',').map(sel => parseSelector(sel)).join(',') : null;
736  };
737  const SelectorEngine = {
738    find(selector, element = document.documentElement) {
739      return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
740    },
741    findOne(selector, element = document.documentElement) {
742      return Element.prototype.querySelector.call(element, selector);
743    },
744    children(element, selector) {
745      return [].concat(...element.children).filter(child => child.matches(selector));
746    },
747    parents(element, selector) {
748      const parents = [];
749      let ancestor = element.parentNode.closest(selector);
750      while (ancestor) {
751        parents.push(ancestor);
752        ancestor = ancestor.parentNode.closest(selector);
753      }
754      return parents;
755    },
756    prev(element, selector) {
757      let previous = element.previousElementSibling;
758      while (previous) {
759        if (previous.matches(selector)) {
760          return [previous];
761        }
762        previous = previous.previousElementSibling;
763      }
764      return [];
765    },
766    // TODO: this is now unused; remove later along with prev()
767    next(element, selector) {
768      let next = element.nextElementSibling;
769      while (next) {
770        if (next.matches(selector)) {
771          return [next];
772        }
773        next = next.nextElementSibling;
774      }
775      return [];
776    },
777    focusableChildren(element) {
778      const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(selector => `${selector}:not([tabindex^="-"])`).join(',');
779      return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el));
780    },
781    getSelectorFromElement(element) {
782      const selector = getSelector(element);
783      if (selector) {
784        return SelectorEngine.findOne(selector) ? selector : null;
785      }
786      return null;
787    },
788    getElementFromSelector(element) {
789      const selector = getSelector(element);
790      return selector ? SelectorEngine.findOne(selector) : null;
791    },
792    getMultipleElementsFromSelector(element) {
793      const selector = getSelector(element);
794      return selector ? SelectorEngine.find(selector) : [];
795    }
796  };
797
798  /**
799   * --------------------------------------------------------------------------
800   * Bootstrap util/component-functions.js
801   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
802   * --------------------------------------------------------------------------
803   */
804
805  const enableDismissTrigger = (component, method = 'hide') => {
806    const clickEvent = `click.dismiss${component.EVENT_KEY}`;
807    const name = component.NAME;
808    EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) {
809      if (['A', 'AREA'].includes(this.tagName)) {
810        event.preventDefault();
811      }
812      if (isDisabled(this)) {
813        return;
814      }
815      const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`);
816      const instance = component.getOrCreateInstance(target);
817
818      // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
819      instance[method]();
820    });
821  };
822
823  /**
824   * --------------------------------------------------------------------------
825   * Bootstrap alert.js
826   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
827   * --------------------------------------------------------------------------
828   */
829
830
831  /**
832   * Constants
833   */
834
835  const NAME$f = 'alert';
836  const DATA_KEY$a = 'bs.alert';
837  const EVENT_KEY$b = `.${DATA_KEY$a}`;
838  const EVENT_CLOSE = `close${EVENT_KEY$b}`;
839  const EVENT_CLOSED = `closed${EVENT_KEY$b}`;
840  const CLASS_NAME_FADE$5 = 'fade';
841  const CLASS_NAME_SHOW$8 = 'show';
842
843  /**
844   * Class definition
845   */
846
847  class Alert extends BaseComponent {
848    // Getters
849    static get NAME() {
850      return NAME$f;
851    }
852
853    // Public
854    close() {
855      const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
856      if (closeEvent.defaultPrevented) {
857        return;
858      }
859      this._element.classList.remove(CLASS_NAME_SHOW$8);
860      const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
861      this._queueCallback(() => this._destroyElement(), this._element, isAnimated);
862    }
863
864    // Private
865    _destroyElement() {
866      this._element.remove();
867      EventHandler.trigger(this._element, EVENT_CLOSED);
868      this.dispose();
869    }
870
871    // Static
872    static jQueryInterface(config) {
873      return this.each(function () {
874        const data = Alert.getOrCreateInstance(this);
875        if (typeof config !== 'string') {
876          return;
877        }
878        if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
879          throw new TypeError(`No method named "${config}"`);
880        }
881        data[config](this);
882      });
883    }
884  }
885
886  /**
887   * Data API implementation
888   */
889
890  enableDismissTrigger(Alert, 'close');
891
892  /**
893   * jQuery
894   */
895
896  defineJQueryPlugin(Alert);
897
898  /**
899   * --------------------------------------------------------------------------
900   * Bootstrap button.js
901   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
902   * --------------------------------------------------------------------------
903   */
904
905
906  /**
907   * Constants
908   */
909
910  const NAME$e = 'button';
911  const DATA_KEY$9 = 'bs.button';
912  const EVENT_KEY$a = `.${DATA_KEY$9}`;
913  const DATA_API_KEY$6 = '.data-api';
914  const CLASS_NAME_ACTIVE$3 = 'active';
915  const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
916  const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`;
917
918  /**
919   * Class definition
920   */
921
922  class Button extends BaseComponent {
923    // Getters
924    static get NAME() {
925      return NAME$e;
926    }
927
928    // Public
929    toggle() {
930      // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
931      this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3));
932    }
933
934    // Static
935    static jQueryInterface(config) {
936      return this.each(function () {
937        const data = Button.getOrCreateInstance(this);
938        if (config === 'toggle') {
939          data[config]();
940        }
941      });
942    }
943  }
944
945  /**
946   * Data API implementation
947   */
948
949  EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => {
950    event.preventDefault();
951    const button = event.target.closest(SELECTOR_DATA_TOGGLE$5);
952    const data = Button.getOrCreateInstance(button);
953    data.toggle();
954  });
955
956  /**
957   * jQuery
958   */
959
960  defineJQueryPlugin(Button);
961
962  /**
963   * --------------------------------------------------------------------------
964   * Bootstrap util/swipe.js
965   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
966   * --------------------------------------------------------------------------
967   */
968
969
970  /**
971   * Constants
972   */
973
974  const NAME$d = 'swipe';
975  const EVENT_KEY$9 = '.bs.swipe';
976  const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$9}`;
977  const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$9}`;
978  const EVENT_TOUCHEND = `touchend${EVENT_KEY$9}`;
979  const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$9}`;
980  const EVENT_POINTERUP = `pointerup${EVENT_KEY$9}`;
981  const POINTER_TYPE_TOUCH = 'touch';
982  const POINTER_TYPE_PEN = 'pen';
983  const CLASS_NAME_POINTER_EVENT = 'pointer-event';
984  const SWIPE_THRESHOLD = 40;
985  const Default$c = {
986    endCallback: null,
987    leftCallback: null,
988    rightCallback: null
989  };
990  const DefaultType$c = {
991    endCallback: '(function|null)',
992    leftCallback: '(function|null)',
993    rightCallback: '(function|null)'
994  };
995
996  /**
997   * Class definition
998   */
999
1000  class Swipe extends Config {
1001    constructor(element, config) {
1002      super();
1003      this._element = element;
1004      if (!element || !Swipe.isSupported()) {
1005        return;
1006      }
1007      this._config = this._getConfig(config);
1008      this._deltaX = 0;
1009      this._supportPointerEvents = Boolean(window.PointerEvent);
1010      this._initEvents();
1011    }
1012
1013    // Getters
1014    static get Default() {
1015      return Default$c;
1016    }
1017    static get DefaultType() {
1018      return DefaultType$c;
1019    }
1020    static get NAME() {
1021      return NAME$d;
1022    }
1023
1024    // Public
1025    dispose() {
1026      EventHandler.off(this._element, EVENT_KEY$9);
1027    }
1028
1029    // Private
1030    _start(event) {
1031      if (!this._supportPointerEvents) {
1032        this._deltaX = event.touches[0].clientX;
1033        return;
1034      }
1035      if (this._eventIsPointerPenTouch(event)) {
1036        this._deltaX = event.clientX;
1037      }
1038    }
1039    _end(event) {
1040      if (this._eventIsPointerPenTouch(event)) {
1041        this._deltaX = event.clientX - this._deltaX;
1042      }
1043      this._handleSwipe();
1044      execute(this._config.endCallback);
1045    }
1046    _move(event) {
1047      this._deltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this._deltaX;
1048    }
1049    _handleSwipe() {
1050      const absDeltaX = Math.abs(this._deltaX);
1051      if (absDeltaX <= SWIPE_THRESHOLD) {
1052        return;
1053      }
1054      const direction = absDeltaX / this._deltaX;
1055      this._deltaX = 0;
1056      if (!direction) {
1057        return;
1058      }
1059      execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback);
1060    }
1061    _initEvents() {
1062      if (this._supportPointerEvents) {
1063        EventHandler.on(this._element, EVENT_POINTERDOWN, event => this._start(event));
1064        EventHandler.on(this._element, EVENT_POINTERUP, event => this._end(event));
1065        this._element.classList.add(CLASS_NAME_POINTER_EVENT);
1066      } else {
1067        EventHandler.on(this._element, EVENT_TOUCHSTART, event => this._start(event));
1068        EventHandler.on(this._element, EVENT_TOUCHMOVE, event => this._move(event));
1069        EventHandler.on(this._element, EVENT_TOUCHEND, event => this._end(event));
1070      }
1071    }
1072    _eventIsPointerPenTouch(event) {
1073      return this._supportPointerEvents && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH);
1074    }
1075
1076    // Static
1077    static isSupported() {
1078      return 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
1079    }
1080  }
1081
1082  /**
1083   * --------------------------------------------------------------------------
1084   * Bootstrap carousel.js
1085   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1086   * --------------------------------------------------------------------------
1087   */
1088
1089
1090  /**
1091   * Constants
1092   */
1093
1094  const NAME$c = 'carousel';
1095  const DATA_KEY$8 = 'bs.carousel';
1096  const EVENT_KEY$8 = `.${DATA_KEY$8}`;
1097  const DATA_API_KEY$5 = '.data-api';
1098  const ARROW_LEFT_KEY$1 = 'ArrowLeft';
1099  const ARROW_RIGHT_KEY$1 = 'ArrowRight';
1100  const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
1101
1102  const ORDER_NEXT = 'next';
1103  const ORDER_PREV = 'prev';
1104  const DIRECTION_LEFT = 'left';
1105  const DIRECTION_RIGHT = 'right';
1106  const EVENT_SLIDE = `slide${EVENT_KEY$8}`;
1107  const EVENT_SLID = `slid${EVENT_KEY$8}`;
1108  const EVENT_KEYDOWN$1 = `keydown${EVENT_KEY$8}`;
1109  const EVENT_MOUSEENTER$1 = `mouseenter${EVENT_KEY$8}`;
1110  const EVENT_MOUSELEAVE$1 = `mouseleave${EVENT_KEY$8}`;
1111  const EVENT_DRAG_START = `dragstart${EVENT_KEY$8}`;
1112  const EVENT_LOAD_DATA_API$3 = `load${EVENT_KEY$8}${DATA_API_KEY$5}`;
1113  const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`;
1114  const CLASS_NAME_CAROUSEL = 'carousel';
1115  const CLASS_NAME_ACTIVE$2 = 'active';
1116  const CLASS_NAME_SLIDE = 'slide';
1117  const CLASS_NAME_END = 'carousel-item-end';
1118  const CLASS_NAME_START = 'carousel-item-start';
1119  const CLASS_NAME_NEXT = 'carousel-item-next';
1120  const CLASS_NAME_PREV = 'carousel-item-prev';
1121  const SELECTOR_ACTIVE = '.active';
1122  const SELECTOR_ITEM = '.carousel-item';
1123  const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_ITEM;
1124  const SELECTOR_ITEM_IMG = '.carousel-item img';
1125  const SELECTOR_INDICATORS = '.carousel-indicators';
1126  const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]';
1127  const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
1128  const KEY_TO_DIRECTION = {
1129    [ARROW_LEFT_KEY$1]: DIRECTION_RIGHT,
1130    [ARROW_RIGHT_KEY$1]: DIRECTION_LEFT
1131  };
1132  const Default$b = {
1133    interval: 5000,
1134    keyboard: true,
1135    pause: 'hover',
1136    ride: false,
1137    touch: true,
1138    wrap: true
1139  };
1140  const DefaultType$b = {
1141    interval: '(number|boolean)',
1142    // TODO:v6 remove boolean support
1143    keyboard: 'boolean',
1144    pause: '(string|boolean)',
1145    ride: '(boolean|string)',
1146    touch: 'boolean',
1147    wrap: 'boolean'
1148  };
1149
1150  /**
1151   * Class definition
1152   */
1153
1154  class Carousel extends BaseComponent {
1155    constructor(element, config) {
1156      super(element, config);
1157      this._interval = null;
1158      this._activeElement = null;
1159      this._isSliding = false;
1160      this.touchTimeout = null;
1161      this._swipeHelper = null;
1162      this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
1163      this._addEventListeners();
1164      if (this._config.ride === CLASS_NAME_CAROUSEL) {
1165        this.cycle();
1166      }
1167    }
1168
1169    // Getters
1170    static get Default() {
1171      return Default$b;
1172    }
1173    static get DefaultType() {
1174      return DefaultType$b;
1175    }
1176    static get NAME() {
1177      return NAME$c;
1178    }
1179
1180    // Public
1181    next() {
1182      this._slide(ORDER_NEXT);
1183    }
1184    nextWhenVisible() {
1185      // FIXME TODO use `document.visibilityState`
1186      // Don't call next when the page isn't visible
1187      // or the carousel or its parent isn't visible
1188      if (!document.hidden && isVisible(this._element)) {
1189        this.next();
1190      }
1191    }
1192    prev() {
1193      this._slide(ORDER_PREV);
1194    }
1195    pause() {
1196      if (this._isSliding) {
1197        triggerTransitionEnd(this._element);
1198      }
1199      this._clearInterval();
1200    }
1201    cycle() {
1202      this._clearInterval();
1203      this._updateInterval();
1204      this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);
1205    }
1206    _maybeEnableCycle() {
1207      if (!this._config.ride) {
1208        return;
1209      }
1210      if (this._isSliding) {
1211        EventHandler.one(this._element, EVENT_SLID, () => this.cycle());
1212        return;
1213      }
1214      this.cycle();
1215    }
1216    to(index) {
1217      const items = this._getItems();
1218      if (index > items.length - 1 || index < 0) {
1219        return;
1220      }
1221      if (this._isSliding) {
1222        EventHandler.one(this._element, EVENT_SLID, () => this.to(index));
1223        return;
1224      }
1225      const activeIndex = this._getItemIndex(this._getActive());
1226      if (activeIndex === index) {
1227        return;
1228      }
1229      const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
1230      this._slide(order, items[index]);
1231    }
1232    dispose() {
1233      if (this._swipeHelper) {
1234        this._swipeHelper.dispose();
1235      }
1236      super.dispose();
1237    }
1238
1239    // Private
1240    _configAfterMerge(config) {
1241      config.defaultInterval = config.interval;
1242      return config;
1243    }
1244    _addEventListeners() {
1245      if (this._config.keyboard) {
1246        EventHandler.on(this._element, EVENT_KEYDOWN$1, event => this._keydown(event));
1247      }
1248      if (this._config.pause === 'hover') {
1249        EventHandler.on(this._element, EVENT_MOUSEENTER$1, () => this.pause());
1250        EventHandler.on(this._element, EVENT_MOUSELEAVE$1, () => this._maybeEnableCycle());
1251      }
1252      if (this._config.touch && Swipe.isSupported()) {
1253        this._addTouchEventListeners();
1254      }
1255    }
1256    _addTouchEventListeners() {
1257      for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {
1258        EventHandler.on(img, EVENT_DRAG_START, event => event.preventDefault());
1259      }
1260      const endCallBack = () => {
1261        if (this._config.pause !== 'hover') {
1262          return;
1263        }
1264
1265        // If it's a touch-enabled device, mouseenter/leave are fired as
1266        // part of the mouse compatibility events on first tap - the carousel
1267        // would stop cycling until user tapped out of it;
1268        // here, we listen for touchend, explicitly pause the carousel
1269        // (as if it's the second time we tap on it, mouseenter compat event
1270        // is NOT fired) and after a timeout (to allow for mouse compatibility
1271        // events to fire) we explicitly restart cycling
1272
1273        this.pause();
1274        if (this.touchTimeout) {
1275          clearTimeout(this.touchTimeout);
1276        }
1277        this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval);
1278      };
1279      const swipeConfig = {
1280        leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
1281        rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
1282        endCallback: endCallBack
1283      };
1284      this._swipeHelper = new Swipe(this._element, swipeConfig);
1285    }
1286    _keydown(event) {
1287      if (/input|textarea/i.test(event.target.tagName)) {
1288        return;
1289      }
1290      const direction = KEY_TO_DIRECTION[event.key];
1291      if (direction) {
1292        event.preventDefault();
1293        this._slide(this._directionToOrder(direction));
1294      }
1295    }
1296    _getItemIndex(element) {
1297      return this._getItems().indexOf(element);
1298    }
1299    _setActiveIndicatorElement(index) {
1300      if (!this._indicatorsElement) {
1301        return;
1302      }
1303      const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
1304      activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);
1305      activeIndicator.removeAttribute('aria-current');
1306      const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement);
1307      if (newActiveIndicator) {
1308        newActiveIndicator.classList.add(CLASS_NAME_ACTIVE$2);
1309        newActiveIndicator.setAttribute('aria-current', 'true');
1310      }
1311    }
1312    _updateInterval() {
1313      const element = this._activeElement || this._getActive();
1314      if (!element) {
1315        return;
1316      }
1317      const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
1318      this._config.interval = elementInterval || this._config.defaultInterval;
1319    }
1320    _slide(order, element = null) {
1321      if (this._isSliding) {
1322        return;
1323      }
1324      const activeElement = this._getActive();
1325      const isNext = order === ORDER_NEXT;
1326      const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);
1327      if (nextElement === activeElement) {
1328        return;
1329      }
1330      const nextElementIndex = this._getItemIndex(nextElement);
1331      const triggerEvent = eventName => {
1332        return EventHandler.trigger(this._element, eventName, {
1333          relatedTarget: nextElement,
1334          direction: this._orderToDirection(order),
1335          from: this._getItemIndex(activeElement),
1336          to: nextElementIndex
1337        });
1338      };
1339      const slideEvent = triggerEvent(EVENT_SLIDE);
1340      if (slideEvent.defaultPrevented) {
1341        return;
1342      }
1343      if (!activeElement || !nextElement) {
1344        // Some weirdness is happening, so we bail
1345        // TODO: change tests that use empty divs to avoid this check
1346        return;
1347      }
1348      const isCycling = Boolean(this._interval);
1349      this.pause();
1350      this._isSliding = true;
1351      this._setActiveIndicatorElement(nextElementIndex);
1352      this._activeElement = nextElement;
1353      const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
1354      const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
1355      nextElement.classList.add(orderClassName);
1356      reflow(nextElement);
1357      activeElement.classList.add(directionalClassName);
1358      nextElement.classList.add(directionalClassName);
1359      const completeCallBack = () => {
1360        nextElement.classList.remove(directionalClassName, orderClassName);
1361        nextElement.classList.add(CLASS_NAME_ACTIVE$2);
1362        activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
1363        this._isSliding = false;
1364        triggerEvent(EVENT_SLID);
1365      };
1366      this._queueCallback(completeCallBack, activeElement, this._isAnimated());
1367      if (isCycling) {
1368        this.cycle();
1369      }
1370    }
1371    _isAnimated() {
1372      return this._element.classList.contains(CLASS_NAME_SLIDE);
1373    }
1374    _getActive() {
1375      return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
1376    }
1377    _getItems() {
1378      return SelectorEngine.find(SELECTOR_ITEM, this._element);
1379    }
1380    _clearInterval() {
1381      if (this._interval) {
1382        clearInterval(this._interval);
1383        this._interval = null;
1384      }
1385    }
1386    _directionToOrder(direction) {
1387      if (isRTL()) {
1388        return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
1389      }
1390      return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
1391    }
1392    _orderToDirection(order) {
1393      if (isRTL()) {
1394        return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
1395      }
1396      return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
1397    }
1398
1399    // Static
1400    static jQueryInterface(config) {
1401      return this.each(function () {
1402        const data = Carousel.getOrCreateInstance(this, config);
1403        if (typeof config === 'number') {
1404          data.to(config);
1405          return;
1406        }
1407        if (typeof config === 'string') {
1408          if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
1409            throw new TypeError(`No method named "${config}"`);
1410          }
1411          data[config]();
1412        }
1413      });
1414    }
1415  }
1416
1417  /**
1418   * Data API implementation
1419   */
1420
1421  EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, function (event) {
1422    const target = SelectorEngine.getElementFromSelector(this);
1423    if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
1424      return;
1425    }
1426    event.preventDefault();
1427    const carousel = Carousel.getOrCreateInstance(target);
1428    const slideIndex = this.getAttribute('data-bs-slide-to');
1429    if (slideIndex) {
1430      carousel.to(slideIndex);
1431      carousel._maybeEnableCycle();
1432      return;
1433    }
1434    if (Manipulator.getDataAttribute(this, 'slide') === 'next') {
1435      carousel.next();
1436      carousel._maybeEnableCycle();
1437      return;
1438    }
1439    carousel.prev();
1440    carousel._maybeEnableCycle();
1441  });
1442  EventHandler.on(window, EVENT_LOAD_DATA_API$3, () => {
1443    const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
1444    for (const carousel of carousels) {
1445      Carousel.getOrCreateInstance(carousel);
1446    }
1447  });
1448
1449  /**
1450   * jQuery
1451   */
1452
1453  defineJQueryPlugin(Carousel);
1454
1455  /**
1456   * --------------------------------------------------------------------------
1457   * Bootstrap collapse.js
1458   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1459   * --------------------------------------------------------------------------
1460   */
1461
1462
1463  /**
1464   * Constants
1465   */
1466
1467  const NAME$b = 'collapse';
1468  const DATA_KEY$7 = 'bs.collapse';
1469  const EVENT_KEY$7 = `.${DATA_KEY$7}`;
1470  const DATA_API_KEY$4 = '.data-api';
1471  const EVENT_SHOW$6 = `show${EVENT_KEY$7}`;
1472  const EVENT_SHOWN$6 = `shown${EVENT_KEY$7}`;
1473  const EVENT_HIDE$6 = `hide${EVENT_KEY$7}`;
1474  const EVENT_HIDDEN$6 = `hidden${EVENT_KEY$7}`;
1475  const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`;
1476  const CLASS_NAME_SHOW$7 = 'show';
1477  const CLASS_NAME_COLLAPSE = 'collapse';
1478  const CLASS_NAME_COLLAPSING = 'collapsing';
1479  const CLASS_NAME_COLLAPSED = 'collapsed';
1480  const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`;
1481  const CLASS_NAME_HORIZONTAL = 'collapse-horizontal';
1482  const WIDTH = 'width';
1483  const HEIGHT = 'height';
1484  const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';
1485  const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]';
1486  const Default$a = {
1487    parent: null,
1488    toggle: true
1489  };
1490  const DefaultType$a = {
1491    parent: '(null|element)',
1492    toggle: 'boolean'
1493  };
1494
1495  /**
1496   * Class definition
1497   */
1498
1499  class Collapse extends BaseComponent {
1500    constructor(element, config) {
1501      super(element, config);
1502      this._isTransitioning = false;
1503      this._triggerArray = [];
1504      const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);
1505      for (const elem of toggleList) {
1506        const selector = SelectorEngine.getSelectorFromElement(elem);
1507        const filterElement = SelectorEngine.find(selector).filter(foundElement => foundElement === this._element);
1508        if (selector !== null && filterElement.length) {
1509          this._triggerArray.push(elem);
1510        }
1511      }
1512      this._initializeChildren();
1513      if (!this._config.parent) {
1514        this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());
1515      }
1516      if (this._config.toggle) {
1517        this.toggle();
1518      }
1519    }
1520
1521    // Getters
1522    static get Default() {
1523      return Default$a;
1524    }
1525    static get DefaultType() {
1526      return DefaultType$a;
1527    }
1528    static get NAME() {
1529      return NAME$b;
1530    }
1531
1532    // Public
1533    toggle() {
1534      if (this._isShown()) {
1535        this.hide();
1536      } else {
1537        this.show();
1538      }
1539    }
1540    show() {
1541      if (this._isTransitioning || this._isShown()) {
1542        return;
1543      }
1544      let activeChildren = [];
1545
1546      // find active children
1547      if (this._config.parent) {
1548        activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES).filter(element => element !== this._element).map(element => Collapse.getOrCreateInstance(element, {
1549          toggle: false
1550        }));
1551      }
1552      if (activeChildren.length && activeChildren[0]._isTransitioning) {
1553        return;
1554      }
1555      const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$6);
1556      if (startEvent.defaultPrevented) {
1557        return;
1558      }
1559      for (const activeInstance of activeChildren) {
1560        activeInstance.hide();
1561      }
1562      const dimension = this._getDimension();
1563      this._element.classList.remove(CLASS_NAME_COLLAPSE);
1564      this._element.classList.add(CLASS_NAME_COLLAPSING);
1565      this._element.style[dimension] = 0;
1566      this._addAriaAndCollapsedClass(this._triggerArray, true);
1567      this._isTransitioning = true;
1568      const complete = () => {
1569        this._isTransitioning = false;
1570        this._element.classList.remove(CLASS_NAME_COLLAPSING);
1571        this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
1572        this._element.style[dimension] = '';
1573        EventHandler.trigger(this._element, EVENT_SHOWN$6);
1574      };
1575      const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
1576      const scrollSize = `scroll${capitalizedDimension}`;
1577      this._queueCallback(complete, this._element, true);
1578      this._element.style[dimension] = `${this._element[scrollSize]}px`;
1579    }
1580    hide() {
1581      if (this._isTransitioning || !this._isShown()) {
1582        return;
1583      }
1584      const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6);
1585      if (startEvent.defaultPrevented) {
1586        return;
1587      }
1588      const dimension = this._getDimension();
1589      this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;
1590      reflow(this._element);
1591      this._element.classList.add(CLASS_NAME_COLLAPSING);
1592      this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
1593      for (const trigger of this._triggerArray) {
1594        const element = SelectorEngine.getElementFromSelector(trigger);
1595        if (element && !this._isShown(element)) {
1596          this._addAriaAndCollapsedClass([trigger], false);
1597        }
1598      }
1599      this._isTransitioning = true;
1600      const complete = () => {
1601        this._isTransitioning = false;

1602        this._element.classList.remove(CLASS_NAME_COLLAPSING);
1603        this._element.classList.add(CLASS_NAME_COLLAPSE);
1604        EventHandler.trigger(this._element, EVENT_HIDDEN$6);
1605      };
1606      this._element.style[dimension] = '';
1607      this._queueCallback(complete, this._element, true);
1608    }
1609
1610    // Private
1611    _isShown(element = this._element) {
1612      return element.classList.contains(CLASS_NAME_SHOW$7);
1613    }
1614    _configAfterMerge(config) {
1615      config.toggle = Boolean(config.toggle); // Coerce string values
1616      config.parent = getElement(config.parent);
1617      return config;
1618    }
1619    _getDimension() {
1620      return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;
1621    }
1622    _initializeChildren() {
1623      if (!this._config.parent) {
1624        return;
1625      }
1626      const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE$4);
1627      for (const element of children) {
1628        const selected = SelectorEngine.getElementFromSelector(element);
1629        if (selected) {
1630          this._addAriaAndCollapsedClass([element], this._isShown(selected));
1631        }
1632      }
1633    }
1634    _getFirstLevelChildren(selector) {
1635      const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
1636      // remove children if greater depth
1637      return SelectorEngine.find(selector, this._config.parent).filter(element => !children.includes(element));
1638    }
1639    _addAriaAndCollapsedClass(triggerArray, isOpen) {
1640      if (!triggerArray.length) {
1641        return;
1642      }
1643      for (const element of triggerArray) {
1644        element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen);
1645        element.setAttribute('aria-expanded', isOpen);
1646      }
1647    }
1648
1649    // Static
1650    static jQueryInterface(config) {
1651      const _config = {};
1652      if (typeof config === 'string' && /show|hide/.test(config)) {
1653        _config.toggle = false;
1654      }
1655      return this.each(function () {
1656        const data = Collapse.getOrCreateInstance(this, _config);
1657        if (typeof config === 'string') {
1658          if (typeof data[config] === 'undefined') {
1659            throw new TypeError(`No method named "${config}"`);
1660          }
1661          data[config]();
1662        }
1663      });
1664    }
1665  }
1666
1667  /**
1668   * Data API implementation
1669   */
1670
1671  EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {
1672    // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
1673    if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
1674      event.preventDefault();
1675    }
1676    for (const element of SelectorEngine.getMultipleElementsFromSelector(this)) {
1677      Collapse.getOrCreateInstance(element, {
1678        toggle: false
1679      }).toggle();
1680    }
1681  });
1682
1683  /**
1684   * jQuery
1685   */
1686
1687  defineJQueryPlugin(Collapse);
1688
1689  var top = 'top';
1690  var bottom = 'bottom';
1691  var right = 'right';
1692  var left = 'left';
1693  var auto = 'auto';
1694  var basePlacements = [top, bottom, right, left];
1695  var start = 'start';
1696  var end = 'end';
1697  var clippingParents = 'clippingParents';
1698  var viewport = 'viewport';
1699  var popper = 'popper';
1700  var reference = 'reference';
1701  var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {
1702    return acc.concat([placement + "-" + start, placement + "-" + end]);
1703  }, []);
1704  var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {
1705    return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
1706  }, []); // modifiers that need to read the DOM
1707
1708  var beforeRead = 'beforeRead';
1709  var read = 'read';
1710  var afterRead = 'afterRead'; // pure-logic modifiers
1711
1712  var beforeMain = 'beforeMain';
1713  var main = 'main';
1714  var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)
1715
1716  var beforeWrite = 'beforeWrite';
1717  var write = 'write';
1718  var afterWrite = 'afterWrite';
1719  var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
1720
1721  function getNodeName(element) {
1722    return element ? (element.nodeName || '').toLowerCase() : null;
1723  }
1724
1725  function getWindow(node) {
1726    if (node == null) {
1727      return window;
1728    }
1729
1730    if (node.toString() !== '[object Window]') {
1731      var ownerDocument = node.ownerDocument;
1732      return ownerDocument ? ownerDocument.defaultView || window : window;
1733    }
1734
1735    return node;
1736  }
1737
1738  function isElement(node) {
1739    var OwnElement = getWindow(node).Element;
1740    return node instanceof OwnElement || node instanceof Element;
1741  }
1742
1743  function isHTMLElement(node) {
1744    var OwnElement = getWindow(node).HTMLElement;
1745    return node instanceof OwnElement || node instanceof HTMLElement;
1746  }
1747
1748  function isShadowRoot(node) {
1749    // IE 11 has no ShadowRoot
1750    if (typeof ShadowRoot === 'undefined') {
1751      return false;

1752    }
1753
1754    var OwnElement = getWindow(node).ShadowRoot;
1755    return node instanceof OwnElement || node instanceof ShadowRoot;
1756  }
1757
1758  // and applies them to the HTMLElements such as popper and arrow
1759
1760  function applyStyles(_ref) {
1761    var state = _ref.state;
1762    Object.keys(state.elements).forEach(function (name) {
1763      var style = state.styles[name] || {};
1764      var attributes = state.attributes[name] || {};
1765      var element = state.elements[name]; // arrow is optional + virtual elements
1766
1767      if (!isHTMLElement(element) || !getNodeName(element)) {
1768        return;
1769      } // Flow doesn't support to extend this property, but it's the most
1770      // effective way to apply styles to an HTMLElement
1771      // $FlowFixMe[cannot-write]
1772
1773
1774      Object.assign(element.style, style);
1775      Object.keys(attributes).forEach(function (name) {
1776        var value = attributes[name];
1777
1778        if (value === false) {
1779          element.removeAttribute(name);
1780        } else {
1781          element.setAttribute(name, value === true ? '' : value);
1782        }
1783      });
1784    });
1785  }
1786
1787  function effect$2(_ref2) {
1788    var state = _ref2.state;
1789    var initialStyles = {
1790      popper: {
1791        position: state.options.strategy,
1792        left: '0',
1793        top: '0',
1794        margin: '0'
1795      },
1796      arrow: {
1797        position: 'absolute'
1798      },
1799      reference: {}
1800    };
1801    Object.assign(state.elements.popper.style, initialStyles.popper);
1802    state.styles = initialStyles;
1803
1804    if (state.elements.arrow) {
1805      Object.assign(state.elements.arrow.style, initialStyles.arrow);
1806    }
1807
1808    return function () {
1809      Object.keys(state.elements).forEach(function (name) {
1810        var element = state.elements[name];
1811        var attributes = state.attributes[name] || {};
1812        var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
1813
1814        var style = styleProperties.reduce(function (style, property) {
1815          style[property] = '';
1816          return style;
1817        }, {}); // arrow is optional + virtual elements
1818
1819        if (!isHTMLElement(element) || !getNodeName(element)) {
1820          return;
1821        }
1822
1823        Object.assign(element.style, style);
1824        Object.keys(attributes).forEach(function (attribute) {
1825          element.removeAttribute(attribute);
1826        });
1827      });
1828    };
1829  } // eslint-disable-next-line import/no-unused-modules
1830
1831
1832  const applyStyles$1 = {
1833    name: 'applyStyles',
1834    enabled: true,
1835    phase: 'write',
1836    fn: applyStyles,
1837    effect: effect$2,
1838    requires: ['computeStyles']
1839  };
1840
1841  function getBasePlacement(placement) {
1842    return placement.split('-')[0];
1843  }
1844
1845  var max = Math.max;
1846  var min = Math.min;
1847  var round = Math.round;
1848
1849  function getUAString() {
1850    var uaData = navigator.userAgentData;
1851
1852    if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) {
1853      return uaData.brands.map(function (item) {
1854        return item.brand + "/" + item.version;
1855      }).join(' ');
1856    }
1857
1858    return navigator.userAgent;
1859  }
1860
1861  function isLayoutViewport() {
1862    return !/^((?!chrome|android).)*safari/i.test(getUAString());
1863  }
1864
1865  function getBoundingClientRect(element, includeScale, isFixedStrategy) {
1866    if (includeScale === void 0) {
1867      includeScale = false;
1868    }
1869
1870    if (isFixedStrategy === void 0) {
1871      isFixedStrategy = false;
1872    }
1873
1874    var clientRect = element.getBoundingClientRect();
1875    var scaleX = 1;
1876    var scaleY = 1;
1877
1878    if (includeScale && isHTMLElement(element)) {
1879      scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
1880      scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
1881    }
1882
1883    var _ref = isElement(element) ? getWindow(element) : window,
1884        visualViewport = _ref.visualViewport;
1885
1886    var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
1887    var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
1888    var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
1889    var width = clientRect.width / scaleX;
1890    var height = clientRect.height / scaleY;
1891    return {
1892      width: width,
1893      height: height,
1894      top: y,
1895      right: x + width,
1896      bottom: y + height,
1897      left: x,
1898      x: x,
1899      y: y
1900    };
1901  }
1902
1903  // means it doesn't take into account transforms.
1904
1905  function getLayoutRect(element) {
1906    var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.
1907    // Fixes https://github.com/popperjs/popper-core/issues/1223
1908
1909    var width = element.offsetWidth;
1910    var height = element.offsetHeight;
1911
1912    if (Math.abs(clientRect.width - width) <= 1) {
1913      width = clientRect.width;
1914    }
1915
1916    if (Math.abs(clientRect.height - height) <= 1) {
1917      height = clientRect.height;
1918    }
1919
1920    return {
1921      x: element.offsetLeft,
1922      y: element.offsetTop,
1923      width: width,
1924      height: height
1925    };
1926  }
1927
1928  function contains(parent, child) {
1929    var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method
1930
1931    if (parent.contains(child)) {
1932      return true;
1933    } // then fallback to custom implementation with Shadow DOM support
1934    else if (rootNode && isShadowRoot(rootNode)) {
1935        var next = child;
1936
1937        do {
1938          if (next && parent.isSameNode(next)) {
1939            return true;
1940          } // $FlowFixMe[prop-missing]: need a better way to handle this...
1941
1942
1943          next = next.parentNode || next.host;
1944        } while (next);
1945      } // Give up, the result is false
1946
1947
1948    return false;
1949  }
1950
1951  function getComputedStyle$1(element) {
1952    return getWindow(element).getComputedStyle(element);
1953  }
1954
1955  function isTableElement(element) {
1956    return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
1957  }
1958
1959  function getDocumentElement(element) {
1960    // $FlowFixMe[incompatible-return]: assume body is always available
1961    return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
1962    element.document) || window.document).documentElement;
1963  }
1964
1965  function getParentNode(element) {
1966    if (getNodeName(element) === 'html') {
1967      return element;
1968    }
1969
1970    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
1971      // $FlowFixMe[incompatible-return]
1972      // $FlowFixMe[prop-missing]
1973      element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
1974      element.parentNode || ( // DOM Element detected
1975      isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
1976      // $FlowFixMe[incompatible-call]: HTMLElement is a Node
1977      getDocumentElement(element) // fallback
1978
1979    );
1980  }
1981
1982  function getTrueOffsetParent(element) {
1983    if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
1984    getComputedStyle$1(element).position === 'fixed') {
1985      return null;
1986    }
1987
1988    return element.offsetParent;
1989  } // `.offsetParent` reports `null` for fixed elements, while absolute elements
1990  // return the containing block
1991
1992
1993  function getContainingBlock(element) {
1994    var isFirefox = /firefox/i.test(getUAString());
1995    var isIE = /Trident/i.test(getUAString());
1996
1997    if (isIE && isHTMLElement(element)) {
1998      // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
1999      var elementCss = getComputedStyle$1(element);
2000
2001      if (elementCss.position === 'fixed') {
2002        return null;
2003      }
2004    }
2005
2006    var currentNode = getParentNode(element);
2007
2008    if (isShadowRoot(currentNode)) {
2009      currentNode = currentNode.host;
2010    }
2011
2012    while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
2013      var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that
2014      // create a containing block.
2015      // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
2016
2017      if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') {
2018        return currentNode;
2019      } else {
2020        currentNode = currentNode.parentNode;
2021      }
2022    }
2023
2024    return null;
2025  } // Gets the closest ancestor positioned element. Handles some edge cases,
2026  // such as table ancestors and cross browser bugs.
2027
2028
2029  function getOffsetParent(element) {
2030    var window = getWindow(element);
2031    var offsetParent = getTrueOffsetParent(element);
2032
2033    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
2034      offsetParent = getTrueOffsetParent(offsetParent);
2035    }
2036
2037    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static')) {
2038      return window;
2039    }
2040
2041    return offsetParent || getContainingBlock(element) || window;
2042  }
2043
2044  function getMainAxisFromPlacement(placement) {
2045    return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
2046  }
2047
2048  function within(min$1, value, max$1) {
2049    return max(min$1, min(value, max$1));
2050  }
2051  function withinMaxClamp(min, value, max) {
2052    var v = within(min, value, max);
2053    return v > max ? max : v;
2054  }
2055
2056  function getFreshSideObject() {
2057    return {
2058      top: 0,
2059      right: 0,
2060      bottom: 0,
2061      left: 0
2062    };
2063  }
2064
2065  function mergePaddingObject(paddingObject) {
2066    return Object.assign({}, getFreshSideObject(), paddingObject);
2067  }
2068
2069  function expandToHashMap(value, keys) {
2070    return keys.reduce(function (hashMap, key) {
2071      hashMap[key] = value;
2072      return hashMap;
2073    }, {});
2074  }
2075
2076  var toPaddingObject = function toPaddingObject(padding, state) {
2077    padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, {
2078      placement: state.placement
2079    })) : padding;
2080    return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2081  };
2082
2083  function arrow(_ref) {
2084    var _state$modifiersData$;
2085
2086    var state = _ref.state,
2087        name = _ref.name,
2088        options = _ref.options;
2089    var arrowElement = state.elements.arrow;
2090    var popperOffsets = state.modifiersData.popperOffsets;
2091    var basePlacement = getBasePlacement(state.placement);
2092    var axis = getMainAxisFromPlacement(basePlacement);
2093    var isVertical = [left, right].indexOf(basePlacement) >= 0;
2094    var len = isVertical ? 'height' : 'width';
2095
2096    if (!arrowElement || !popperOffsets) {
2097      return;
2098    }
2099
2100    var paddingObject = toPaddingObject(options.padding, state);
2101    var arrowRect = getLayoutRect(arrowElement);
2102    var minProp = axis === 'y' ? top : left;
2103    var maxProp = axis === 'y' ? bottom : right;
2104    var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
2105    var startDiff = popperOffsets[axis] - state.rects.reference[axis];
2106    var arrowOffsetParent = getOffsetParent(arrowElement);
2107    var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
2108    var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
2109    // outside of the popper bounds
2110
2111    var min = paddingObject[minProp];
2112    var max = clientSize - arrowRect[len] - paddingObject[maxProp];
2113    var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
2114    var offset = within(min, center, max); // Prevents breaking syntax highlighting...
2115
2116    var axisProp = axis;
2117    state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
2118  }
2119
2120  function effect$1(_ref2) {
2121    var state = _ref2.state,
2122        options = _ref2.options;
2123    var _options$element = options.element,
2124        arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element;
2125
2126    if (arrowElement == null) {
2127      return;
2128    } // CSS selector
2129
2130
2131    if (typeof arrowElement === 'string') {
2132      arrowElement = state.elements.popper.querySelector(arrowElement);
2133
2134      if (!arrowElement) {
2135        return;
2136      }
2137    }
2138
2139    if (!contains(state.elements.popper, arrowElement)) {
2140      return;
2141    }
2142
2143    state.elements.arrow = arrowElement;
2144  } // eslint-disable-next-line import/no-unused-modules
2145
2146
2147  const arrow$1 = {
2148    name: 'arrow',
2149    enabled: true,
2150    phase: 'main',
2151    fn: arrow,
2152    effect: effect$1,
2153    requires: ['popperOffsets'],
2154    requiresIfExists: ['preventOverflow']
2155  };
2156
2157  function getVariation(placement) {
2158    return placement.split('-')[1];
2159  }
2160
2161  var unsetSides = {
2162    top: 'auto',
2163    right: 'auto',
2164    bottom: 'auto',
2165    left: 'auto'
2166  }; // Round the offsets to the nearest suitable subpixel based on the DPR.
2167  // Zooming can change the DPR, but it seems to report a value that will
2168  // cleanly divide the values into the appropriate subpixels.
2169
2170  function roundOffsetsByDPR(_ref, win) {
2171    var x = _ref.x,
2172        y = _ref.y;
2173    var dpr = win.devicePixelRatio || 1;
2174    return {
2175      x: round(x * dpr) / dpr || 0,
2176      y: round(y * dpr) / dpr || 0
2177    };
2178  }
2179
2180  function mapToStyles(_ref2) {
2181    var _Object$assign2;
2182
2183    var popper = _ref2.popper,
2184        popperRect = _ref2.popperRect,
2185        placement = _ref2.placement,
2186        variation = _ref2.variation,
2187        offsets = _ref2.offsets,
2188        position = _ref2.position,
2189        gpuAcceleration = _ref2.gpuAcceleration,
2190        adaptive = _ref2.adaptive,
2191        roundOffsets = _ref2.roundOffsets,
2192        isFixed = _ref2.isFixed;
2193    var _offsets$x = offsets.x,
2194        x = _offsets$x === void 0 ? 0 : _offsets$x,
2195        _offsets$y = offsets.y,
2196        y = _offsets$y === void 0 ? 0 : _offsets$y;
2197
2198    var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({
2199      x: x,
2200      y: y
2201    }) : {
2202      x: x,
2203      y: y
2204    };
2205
2206    x = _ref3.x;
2207    y = _ref3.y;
2208    var hasX = offsets.hasOwnProperty('x');
2209    var hasY = offsets.hasOwnProperty('y');
2210    var sideX = left;
2211    var sideY = top;
2212    var win = window;
2213
2214    if (adaptive) {
2215      var offsetParent = getOffsetParent(popper);
2216      var heightProp = 'clientHeight';
2217      var widthProp = 'clientWidth';
2218
2219      if (offsetParent === getWindow(popper)) {
2220        offsetParent = getDocumentElement(popper);
2221
2222        if (getComputedStyle$1(offsetParent).position !== 'static' && position === 'absolute') {
2223          heightProp = 'scrollHeight';
2224          widthProp = 'scrollWidth';
2225        }
2226      } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
2227
2228
2229      offsetParent = offsetParent;
2230
2231      if (placement === top || (placement === left || placement === right) && variation === end) {
2232        sideY = bottom;
2233        var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing]
2234        offsetParent[heightProp];
2235        y -= offsetY - popperRect.height;
2236        y *= gpuAcceleration ? 1 : -1;
2237      }
2238
2239      if (placement === left || (placement === top || placement === bottom) && variation === end) {
2240        sideX = right;
2241        var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing]
2242        offsetParent[widthProp];
2243        x -= offsetX - popperRect.width;
2244        x *= gpuAcceleration ? 1 : -1;
2245      }
2246    }
2247
2248    var commonStyles = Object.assign({
2249      position: position
2250    }, adaptive && unsetSides);
2251
2252    var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
2253      x: x,
2254      y: y
2255    }, getWindow(popper)) : {
2256      x: x,
2257      y: y
2258    };
2259
2260    x = _ref4.x;
2261    y = _ref4.y;
2262
2263    if (gpuAcceleration) {
2264      var _Object$assign;
2265
2266      return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
2267    }
2268
2269    return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
2270  }
2271
2272  function computeStyles(_ref5) {
2273    var state = _ref5.state,
2274        options = _ref5.options;
2275    var _options$gpuAccelerat = options.gpuAcceleration,
2276        gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
2277        _options$adaptive = options.adaptive,
2278        adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
2279        _options$roundOffsets = options.roundOffsets,
2280        roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
2281    var commonStyles = {
2282      placement: getBasePlacement(state.placement),
2283      variation: getVariation(state.placement),
2284      popper: state.elements.popper,
2285      popperRect: state.rects.popper,
2286      gpuAcceleration: gpuAcceleration,
2287      isFixed: state.options.strategy === 'fixed'
2288    };
2289
2290    if (state.modifiersData.popperOffsets != null) {
2291      state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
2292        offsets: state.modifiersData.popperOffsets,
2293        position: state.options.strategy,
2294        adaptive: adaptive,
2295        roundOffsets: roundOffsets
2296      })));
2297    }
2298
2299    if (state.modifiersData.arrow != null) {
2300      state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
2301        offsets: state.modifiersData.arrow,
2302        position: 'absolute',
2303        adaptive: false,
2304        roundOffsets: roundOffsets
2305      })));
2306    }
2307
2308    state.attributes.popper = Object.assign({}, state.attributes.popper, {
2309      'data-popper-placement': state.placement
2310    });
2311  } // eslint-disable-next-line import/no-unused-modules
2312
2313
2314  const computeStyles$1 = {
2315    name: 'computeStyles',
2316    enabled: true,
2317    phase: 'beforeWrite',
2318    fn: computeStyles,
2319    data: {}
2320  };
2321
2322  var passive = {
2323    passive: true
2324  };
2325
2326  function effect(_ref) {
2327    var state = _ref.state,
2328        instance = _ref.instance,
2329        options = _ref.options;
2330    var _options$scroll = options.scroll,
2331        scroll = _options$scroll === void 0 ? true : _options$scroll,
2332        _options$resize = options.resize,
2333        resize = _options$resize === void 0 ? true : _options$resize;
2334    var window = getWindow(state.elements.popper);
2335    var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
2336
2337    if (scroll) {
2338      scrollParents.forEach(function (scrollParent) {
2339        scrollParent.addEventListener('scroll', instance.update, passive);
2340      });
2341    }
2342
2343    if (resize) {
2344      window.addEventListener('resize', instance.update, passive);
2345    }
2346
2347    return function () {
2348      if (scroll) {
2349        scrollParents.forEach(function (scrollParent) {
2350          scrollParent.removeEventListener('scroll', instance.update, passive);
2351        });
2352      }
2353
2354      if (resize) {
2355        window.removeEventListener('resize', instance.update, passive);
2356      }
2357    };
2358  } // eslint-disable-next-line import/no-unused-modules
2359
2360
2361  const eventListeners = {
2362    name: 'eventListeners',
2363    enabled: true,
2364    phase: 'write',
2365    fn: function fn() {},
2366    effect: effect,
2367    data: {}
2368  };
2369
2370  var hash$1 = {
2371    left: 'right',
2372    right: 'left',
2373    bottom: 'top',
2374    top: 'bottom'
2375  };
2376  function getOppositePlacement(placement) {
2377    return placement.replace(/left|right|bottom|top/g, function (matched) {
2378      return hash$1[matched];
2379    });
2380  }
2381
2382  var hash = {
2383    start: 'end',
2384    end: 'start'
2385  };
2386  function getOppositeVariationPlacement(placement) {
2387    return placement.replace(/start|end/g, function (matched) {
2388      return hash[matched];
2389    });
2390  }
2391
2392  function getWindowScroll(node) {
2393    var win = getWindow(node);
2394    var scrollLeft = win.pageXOffset;
2395    var scrollTop = win.pageYOffset;
2396    return {
2397      scrollLeft: scrollLeft,
2398      scrollTop: scrollTop
2399    };
2400  }
2401
2402  function getWindowScrollBarX(element) {
2403    // If <html> has a CSS width greater than the viewport, then this will be
2404    // incorrect for RTL.
2405    // Popper 1 is broken in this case and never had a bug report so let's assume
2406    // it's not an issue. I don't think anyone ever specifies width on <html>
2407    // anyway.
2408    // Browsers where the left scrollbar doesn't cause an issue report `0` for
2409    // this (e.g. Edge 2019, IE11, Safari)
2410    return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
2411  }
2412
2413  function getViewportRect(element, strategy) {
2414    var win = getWindow(element);
2415    var html = getDocumentElement(element);
2416    var visualViewport = win.visualViewport;
2417    var width = html.clientWidth;
2418    var height = html.clientHeight;
2419    var x = 0;
2420    var y = 0;
2421
2422    if (visualViewport) {
2423      width = visualViewport.width;
2424      height = visualViewport.height;
2425      var layoutViewport = isLayoutViewport();
2426
2427      if (layoutViewport || !layoutViewport && strategy === 'fixed') {
2428        x = visualViewport.offsetLeft;
2429        y = visualViewport.offsetTop;
2430      }
2431    }
2432
2433    return {
2434      width: width,
2435      height: height,
2436      x: x + getWindowScrollBarX(element),
2437      y: y
2438    };
2439  }
2440
2441  // of the `<html>` and `<body>` rect bounds if horizontally scrollable
2442
2443  function getDocumentRect(element) {
2444    var _element$ownerDocumen;
2445
2446    var html = getDocumentElement(element);
2447    var winScroll = getWindowScroll(element);
2448    var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
2449    var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
2450    var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
2451    var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
2452    var y = -winScroll.scrollTop;
2453
2454    if (getComputedStyle$1(body || html).direction === 'rtl') {
2455      x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
2456    }
2457
2458    return {
2459      width: width,
2460      height: height,
2461      x: x,
2462      y: y
2463    };
2464  }
2465
2466  function isScrollParent(element) {
2467    // Firefox wants us to check `-x` and `-y` variations as well
2468    var _getComputedStyle = getComputedStyle$1(element),
2469        overflow = _getComputedStyle.overflow,
2470        overflowX = _getComputedStyle.overflowX,
2471        overflowY = _getComputedStyle.overflowY;
2472
2473    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
2474  }
2475
2476  function getScrollParent(node) {
2477    if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
2478      // $FlowFixMe[incompatible-return]: assume body is always available
2479      return node.ownerDocument.body;
2480    }
2481
2482    if (isHTMLElement(node) && isScrollParent(node)) {
2483      return node;
2484    }
2485
2486    return getScrollParent(getParentNode(node));
2487  }
2488
2489  /*
2490  given a DOM element, return the list of all scroll parents, up the list of ancesors
2491  until we get to the top window object. This list is what we attach scroll listeners
2492  to, because if any of these parent elements scroll, we'll need to re-calculate the
2493  reference element's position.
2494  */
2495
2496  function listScrollParents(element, list) {
2497    var _element$ownerDocumen;
2498
2499    if (list === void 0) {
2500      list = [];
2501    }
2502
2503    var scrollParent = getScrollParent(element);
2504    var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
2505    var win = getWindow(scrollParent);
2506    var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
2507    var updatedList = list.concat(target);
2508    return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
2509    updatedList.concat(listScrollParents(getParentNode(target)));
2510  }
2511
2512  function rectToClientRect(rect) {
2513    return Object.assign({}, rect, {
2514      left: rect.x,
2515      top: rect.y,
2516      right: rect.x + rect.width,
2517      bottom: rect.y + rect.height
2518    });
2519  }
2520
2521  function getInnerBoundingClientRect(element, strategy) {
2522    var rect = getBoundingClientRect(element, false, strategy === 'fixed');
2523    rect.top = rect.top + element.clientTop;
2524    rect.left = rect.left + element.clientLeft;
2525    rect.bottom = rect.top + element.clientHeight;
2526    rect.right = rect.left + element.clientWidth;
2527    rect.width = element.clientWidth;
2528    rect.height = element.clientHeight;
2529    rect.x = rect.left;
2530    rect.y = rect.top;
2531    return rect;
2532  }
2533
2534  function getClientRectFromMixedType(element, clippingParent, strategy) {
2535    return clippingParent === viewport ? rectToClientRect(getViewportRect(element, strategy)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
2536  } // A "clipping parent" is an overflowable container with the characteristic of
2537  // clipping (or hiding) overflowing elements with a position different from
2538  // `initial`
2539
2540
2541  function getClippingParents(element) {
2542    var clippingParents = listScrollParents(getParentNode(element));
2543    var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0;
2544    var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
2545
2546    if (!isElement(clipperElement)) {
2547      return [];
2548    } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414
2549
2550
2551    return clippingParents.filter(function (clippingParent) {
2552      return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body';
2553    });
2554  } // Gets the maximum area that the element is visible in due to any number of
2555  // clipping parents
2556
2557

2558  function getClippingRect(element, boundary, rootBoundary, strategy) {
2559    var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
2560    var clippingParents = [].concat(mainClippingParents, [rootBoundary]);
2561    var firstClippingParent = clippingParents[0];
2562    var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {
2563      var rect = getClientRectFromMixedType(element, clippingParent, strategy);
2564      accRect.top = max(rect.top, accRect.top);
2565      accRect.right = min(rect.right, accRect.right);
2566      accRect.bottom = min(rect.bottom, accRect.bottom);
2567      accRect.left = max(rect.left, accRect.left);
2568      return accRect;
2569    }, getClientRectFromMixedType(element, firstClippingParent, strategy));
2570    clippingRect.width = clippingRect.right - clippingRect.left;
2571    clippingRect.height = clippingRect.bottom - clippingRect.top;
2572    clippingRect.x = clippingRect.left;
2573    clippingRect.y = clippingRect.top;
2574    return clippingRect;
2575  }
2576
2577  function computeOffsets(_ref) {
2578    var reference = _ref.reference,
2579        element = _ref.element,
2580        placement = _ref.placement;
2581    var basePlacement = placement ? getBasePlacement(placement) : null;
2582    var variation = placement ? getVariation(placement) : null;
2583    var commonX = reference.x + reference.width / 2 - element.width / 2;
2584    var commonY = reference.y + reference.height / 2 - element.height / 2;
2585    var offsets;
2586
2587    switch (basePlacement) {
2588      case top:
2589        offsets = {
2590          x: commonX,
2591          y: reference.y - element.height
2592        };
2593        break;
2594
2595      case bottom:
2596        offsets = {
2597          x: commonX,
2598          y: reference.y + reference.height
2599        };
2600        break;
2601
2602      case right:
2603        offsets = {
2604          x: reference.x + reference.width,
2605          y: commonY
2606        };
2607        break;
2608
2609      case left:
2610        offsets = {
2611          x: reference.x - element.width,
2612          y: commonY
2613        };
2614        break;
2615
2616      default:
2617        offsets = {
2618          x: reference.x,
2619          y: reference.y
2620        };
2621    }
2622
2623    var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
2624
2625    if (mainAxis != null) {
2626      var len = mainAxis === 'y' ? 'height' : 'width';
2627
2628      switch (variation) {
2629        case start:
2630          offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
2631          break;
2632
2633        case end:
2634          offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
2635          break;
2636      }
2637    }
2638
2639    return offsets;
2640  }
2641
2642  function detectOverflow(state, options) {
2643    if (options === void 0) {
2644      options = {};
2645    }
2646
2647    var _options = options,
2648        _options$placement = _options.placement,
2649        placement = _options$placement === void 0 ? state.placement : _options$placement,
2650        _options$strategy = _options.strategy,
2651        strategy = _options$strategy === void 0 ? state.strategy : _options$strategy,
2652        _options$boundary = _options.boundary,
2653        boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,
2654        _options$rootBoundary = _options.rootBoundary,
2655        rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,
2656        _options$elementConte = _options.elementContext,
2657        elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,
2658        _options$altBoundary = _options.altBoundary,
2659        altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,
2660        _options$padding = _options.padding,
2661        padding = _options$padding === void 0 ? 0 : _options$padding;
2662    var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2663    var altContext = elementContext === popper ? reference : popper;
2664    var popperRect = state.rects.popper;
2665    var element = state.elements[altBoundary ? altContext : elementContext];
2666    var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy);
2667    var referenceClientRect = getBoundingClientRect(state.elements.reference);
2668    var popperOffsets = computeOffsets({
2669      reference: referenceClientRect,
2670      element: popperRect,
2671      placement: placement
2672    });
2673    var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets));
2674    var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect
2675    // 0 or negative = within the clipping rect
2676
2677    var overflowOffsets = {
2678      top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
2679      bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
2680      left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
2681      right: elementClientRect.right - clippingClientRect.right + paddingObject.right
2682    };
2683    var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element
2684
2685    if (elementContext === popper && offsetData) {
2686      var offset = offsetData[placement];