https://celona.io/assets/js/main.min.js?mt=1786505257

1(() => {
2  var __create = Object.create;
3  var __defProp = Object.defineProperty;
4  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5  var __getOwnPropNames = Object.getOwnPropertyNames;
6  var __getProtoOf = Object.getPrototypeOf;
7  var __hasOwnProp = Object.prototype.hasOwnProperty;
8  var __esm = (fn, res) => function __init() {
9    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
10  };
11  var __commonJS = (cb, mod) => function __require() {
12    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
13  };
14  var __copyProps = (to, from, except, desc) => {
15    if (from && typeof from === "object" || typeof from === "function") {
16      for (let key of __getOwnPropNames(from))
17        if (!__hasOwnProp.call(to, key) && key !== except)
18          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
19    }
20    return to;
21  };
22  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
23    // If the importer is in node compatibility mode or this is not an ESM
24    // file that has been converted to a CommonJS file using a Babel-
25    // compatible transform (i.e. "__esModule" has not been set), then set
26    // "default" to the CommonJS "module.exports" for node compatibility.
27    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
28    mod
29  ));
30  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
31
32  

32// node_modules/@popperjs/core/dist/cjs/popper.js
33  var require_popper = __commonJS({
34    "node_modules/@popperjs/core/dist/cjs/popper.js"(exports) {
35      "use strict";
36      Object.defineProperty(exports, "__esModule", { value: true });
37      function getWindow(node) {
38        if (node == null) {
39          return window;
40        }
41        if (node.toString() !== "[object Window]") {
42          var ownerDocument = node.ownerDocument;
43          return ownerDocument ? ownerDocument.defaultView || window : window;
44        }
45        return node;
46      }
47      function isElement(node) {
48        var OwnElement = getWindow(node).Element;
49        return node instanceof OwnElement || node instanceof Element;
50      }
51      function isHTMLElement(node) {
52        var OwnElement = getWindow(node).HTMLElement;
53        return node instanceof OwnElement || node instanceof HTMLElement;
54      }
55      function isShadowRoot(node) {
56        if (typeof ShadowRoot === "undefined") {
57          return false;
58        }
59        var OwnElement = getWindow(node).ShadowRoot;
60        return node instanceof OwnElement || node instanceof ShadowRoot;
61      }
62      var max = Math.max;
63      var min = Math.min;
64      var round = Math.round;
65      function getUAString() {
66        var uaData = navigator.userAgentData;
67        if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) {
68          return uaData.brands.map(function(item) {
69            return item.brand + "/" + item.version;
70          }).join(" ");
71        }
72        return navigator.userAgent;
73      }
74      function isLayoutViewport() {
75        return !/^((?!chrome|android).)*safari/i.test(getUAString());
76      }
77      function getBoundingClientRect(element, includeScale, isFixedStrategy) {
78        if (includeScale === void 0) {
79          includeScale = false;
80        }
81        if (isFixedStrategy === void 0) {
82          isFixedStrategy = false;
83        }
84        var clientRect = element.getBoundingClientRect();
85        var scaleX = 1;
86        var scaleY = 1;
87        if (includeScale && isHTMLElement(element)) {
88          scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
89          scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
90        }
91        var _ref = isElement(element) ? getWindow(element) : window, visualViewport = _ref.visualViewport;
92        var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
93        var x2 = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
94        var y3 = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
95        var width = clientRect.width / scaleX;
96        var height = clientRect.height / scaleY;
97        return {
98          width,
99          height,
100          top: y3,
101          right: x2 + width,
102          bottom: y3 + height,
103          left: x2,
104          x: x2,
105          y: y3
106        };
107      }
108      function getWindowScroll(node) {
109        var win = getWindow(node);
110        var scrollLeft = win.pageXOffset;
111        var scrollTop = win.pageYOffset;
112        return {
113          scrollLeft,
114          scrollTop
115        };
116      }
117      function getHTMLElementScroll(element) {
118        return {
119          scrollLeft: element.scrollLeft,
120          scrollTop: element.scrollTop
121        };
122      }
123      function getNodeScroll(node) {
124        if (node === getWindow(node) || !isHTMLElement(node)) {
125          return getWindowScroll(node);
126        } else {
127          return getHTMLElementScroll(node);
128        }
129      }
130      function getNodeName(element) {
131        return element ? (element.nodeName || "").toLowerCase() : null;
132      }
133      function getDocumentElement(element) {
134        return ((isElement(element) ? element.ownerDocument : (
135          // $FlowFixMe[prop-missing]
136          element.document
137        )) || window.document).documentElement;
138      }
139      function getWindowScrollBarX(element) {
140        return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
141      }
142      function getComputedStyle2(element) {
143        return getWindow(element).getComputedStyle(element);
144      }
145      function isScrollParent(element) {
146        var _getComputedStyle3 = getComputedStyle2(element), overflow = _getComputedStyle3.overflow, overflowX = _getComputedStyle3.overflowX, overflowY = _getComputedStyle3.overflowY;
147        return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
148      }
149      function isElementScaled(element) {
150        var rect = element.getBoundingClientRect();
151        var scaleX = round(rect.width) / element.offsetWidth || 1;
152        var scaleY = round(rect.height) / element.offsetHeight || 1;
153        return scaleX !== 1 || scaleY !== 1;
154      }
155      function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
156        if (isFixed === void 0) {
157          isFixed = false;
158        }
159        var isOffsetParentAnElement = isHTMLElement(offsetParent);
160        var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
161        var documentElement = getDocumentElement(offsetParent);
162        var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed);
163        var scroll = {
164          scrollLeft: 0,
165          scrollTop: 0
166        };
167        var offsets = {
168          x: 0,
169          y: 0
170        };
171        if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
172          if (getNodeName(offsetParent) !== "body" || // https://github.com/popperjs/popper-core/issues/1078
173          isScrollParent(documentElement)) {
174            scroll = getNodeScroll(offsetParent);
175          }
176          if (isHTMLElement(offsetParent)) {
177            offsets = getBoundingClientRect(offsetParent, true);
178            offsets.x += offsetParent.clientLeft;
179            offsets.y += offsetParent.clientTop;
180          } else if (documentElement) {
181            offsets.x = getWindowScrollBarX(documentElement);
182          }
183        }
184        return {
185          x: rect.left + scroll.scrollLeft - offsets.x,
186          y: rect.top + scroll.scrollTop - offsets.y,
187          width: rect.width,
188          height: rect.height
189        };
190      }
191      function getLayoutRect(element) {
192        var clientRect = getBoundingClientRect(element);
193        var width = element.offsetWidth;
194        var height = element.offsetHeight;
195        if (Math.abs(clientRect.width - width) <= 1) {
196          width = clientRect.width;
197        }
198        if (Math.abs(clientRect.height - height) <= 1) {
199          height = clientRect.height;
200        }
201        return {
202          x: element.offsetLeft,
203          y: element.offsetTop,
204          width,
205          height
206        };
207      }
208      function getParentNode(element) {
209        if (getNodeName(element) === "html") {
210          return element;
211        }
212        return (
213          // this is a quicker (but less type safe) way to save quite some bytes from the bundle
214          // $FlowFixMe[incompatible-return]
215          // $FlowFixMe[prop-missing]
216          element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
217          element.parentNode || // DOM Element detected
218          (isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
219          // $FlowFixMe[incompatible-call]: HTMLElement is a Node
220          getDocumentElement(element)
221        );
222      }
223      function getScrollParent(node) {
224        if (["html", "body", "#document"].indexOf(getNodeName(node)) >= 0) {
225          return node.ownerDocument.body;
226        }
227        if (isHTMLElement(node) && isScrollParent(node)) {
228          return node;
229        }
230        return getScrollParent(getParentNode(node));
231      }
232      function listScrollParents(element, list) {
233        var _element$ownerDocumen;
234        if (list === void 0) {
235          list = [];
236        }
237        var scrollParent = getScrollParent(element);
238        var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
239        var win = getWindow(scrollParent);
240        var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
241        var updatedList = list.concat(target);
242        return isBody ? updatedList : (
243          // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
244          updatedList.concat(listScrollParents(getParentNode(target)))
245        );
246      }
247      function isTableElement(element) {
248        return ["table", "td", "th"].indexOf(getNodeName(element)) >= 0;
249      }
250      function getTrueOffsetParent(element) {
251        if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
252        getComputedStyle2(element).position === "fixed") {
253          return null;
254        }
255        return element.offsetParent;
256      }
257      function getContainingBlock(element) {
258        var isFirefox = /firefox/i.test(getUAString());
259        var isIE = /Trident/i.test(getUAString());
260        if (isIE && isHTMLElement(element)) {
261          var elementCss = getComputedStyle2(element);
262          if (elementCss.position === "fixed") {
263            return null;
264          }
265        }
266        var currentNode = getParentNode(element);
267        if (isShadowRoot(currentNode)) {
268          currentNode = currentNode.host;
269        }
270        while (isHTMLElement(currentNode) && ["html", "body"].indexOf(getNodeName(currentNode)) < 0) {
271          var css = getComputedStyle2(currentNode);
272          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") {
273            return currentNode;
274          } else {
275            currentNode = currentNode.parentNode;
276          }
277        }
278        return null;
279      }
280      function getOffsetParent(element) {
281        var window2 = getWindow(element);
282        var offsetParent = getTrueOffsetParent(element);
283        while (offsetParent && isTableElement(offsetParent) && getComputedStyle2(offsetParent).position === "static") {
284          offsetParent = getTrueOffsetParent(offsetParent);
285        }
286        if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle2(offsetParent).position === "static")) {
287          return window2;
288        }
289        return offsetParent || getContainingBlock(element) || window2;
290      }
291      var top = "top";
292      var bottom = "bottom";
293      var right = "right";
294      var left = "left";
295      var auto = "auto";
296      var basePlacements = [top, bottom, right, left];
297      var start = "start";
298      var end = "end";
299      var clippingParents = "clippingParents";
300      var viewport = "viewport";
301      var popper = "popper";
302      var reference = "reference";
303      var variationPlacements = /* @__PURE__ */ basePlacements.reduce(function(acc, placement) {
304        return acc.concat([placement + "-" + start, placement + "-" + end]);
305      }, []);
306      var placements = /* @__PURE__ */ [].concat(basePlacements, [auto]).reduce(function(acc, placement) {
307        return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
308      }, []);
309      var beforeRead = "beforeRead";
310      var read = "read";
311      var afterRead = "afterRead";
312      var beforeMain = "beforeMain";
313      var main = "main";
314      var afterMain = "afterMain";
315      var beforeWrite = "beforeWrite";
316      var write = "write";
317      var afterWrite = "afterWrite";
318      var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
319      function order(modifiers) {
320        var map = /* @__PURE__ */ new Map();
321        var visited = /* @__PURE__ */ new Set();
322        var result = [];
323        modifiers.forEach(function(modifier) {
324          map.set(modifier.name, modifier);
325        });
326        function sort(modifier) {
327          visited.add(modifier.name);
328          var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
329          requires.forEach(function(dep) {
330            if (!visited.has(dep)) {
331              var depModifier = map.get(dep);
332              if (depModifier) {
333                sort(depModifier);
334              }
335            }
336          });
337          result.push(modifier);
338        }
339        modifiers.forEach(function(modifier) {
340          if (!visited.has(modifier.name)) {
341            sort(modifier);
342          }
343        });
344        return result;
345      }
346      function orderModifiers(modifiers) {
347        var orderedModifiers = order(modifiers);
348        return modifierPhases.reduce(function(acc, phase) {
349          return acc.concat(orderedModifiers.filter(function(modifier) {
350            return modifier.phase === phase;
351          }));
352        }, []);
353      }
354      function debounce(fn) {
355        var pending;
356        return function() {
357          if (!pending) {
358            pending = new Promise(function(resolve) {
359              Promise.resolve().then(function() {
360                pending = void 0;
361                resolve(fn());
362              });
363            });
364          }
365          return pending;
366        };
367      }
368      function mergeByName(modifiers) {
369        var merged = modifiers.reduce(function(merged2, current) {
370          var existing = merged2[current.name];
371          merged2[current.name] = existing ? Object.assign({}, existing, current, {
372            options: Object.assign({}, existing.options, current.options),
373            data: Object.assign({}, existing.data, current.data)
374          }) : current;
375          return merged2;
376        }, {});
377        return Object.keys(merged).map(function(key) {
378          return merged[key];
379        });
380      }
381      function getViewportRect(element, strategy) {
382        var win = getWindow(element);
383        var html = getDocumentElement(element);
384        var visualViewport = win.visualViewport;
385        var width = html.clientWidth;
386        var height = html.clientHeight;
387        var x2 = 0;
388        var y3 = 0;
389        if (visualViewport) {
390          width = visualViewport.width;
391          height = visualViewport.height;
392          var layoutViewport = isLayoutViewport();
393          if (layoutViewport || !layoutViewport && strategy === "fixed") {
394            x2 = visualViewport.offsetLeft;
395            y3 = visualViewport.offsetTop;
396          }
397        }
398        return {
399          width,
400          height,
401          x: x2 + getWindowScrollBarX(element),
402          y: y3
403        };
404      }
405      function getDocumentRect(element) {
406        var _element$ownerDocumen;
407        var html = getDocumentElement(element);
408        var winScroll = getWindowScroll(element);
409        var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
410        var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
411        var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
412        var x2 = -winScroll.scrollLeft + getWindowScrollBarX(element);
413        var y3 = -winScroll.scrollTop;
414        if (getComputedStyle2(body || html).direction === "rtl") {
415          x2 += max(html.clientWidth, body ? body.clientWidth : 0) - width;
416        }
417        return {
418          width,
419          height,
420          x: x2,
421          y: y3
422        };
423      }
424      function contains(parent, child) {
425        var rootNode = child.getRootNode && child.getRootNode();
426        if (parent.contains(child)) {
427          return true;
428        } else if (rootNode && isShadowRoot(rootNode)) {
429          var next = child;
430          do {
431            if (next && parent.isSameNode(next)) {
432              return true;
433            }
434            next = next.parentNode || next.host;
435          } while (next);
436        }
437        return false;
438      }
439      function rectToClientRect(rect) {
440        return Object.assign({}, rect, {
441          left: rect.x,
442          top: rect.y,
443          right: rect.x + rect.width,
444          bottom: rect.y + rect.height
445        });
446      }
447      function getInnerBoundingClientRect(element, strategy) {
448        var rect = getBoundingClientRect(element, false, strategy === "fixed");
449        rect.top = rect.top + element.clientTop;
450        rect.left = rect.left + element.clientLeft;
451        rect.bottom = rect.top + element.clientHeight;
452        rect.right = rect.left + element.clientWidth;
453        rect.width = element.clientWidth;
454        rect.height = element.clientHeight;
455        rect.x = rect.left;
456        rect.y = rect.top;
457        return rect;
458      }
459      function getClientRectFromMixedType(element, clippingParent, strategy) {
460        return clippingParent === viewport ? rectToClientRect(getViewportRect(element, strategy)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
461      }
462      function getClippingParents(element) {
463        var clippingParents2 = listScrollParents(getParentNode(element));
464        var canEscapeClipping = ["absolute", "fixed"].indexOf(getComputedStyle2(element).position) >= 0;
465        var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
466        if (!isElement(clipperElement)) {
467          return [];
468        }
469        return clippingParents2.filter(function(clippingParent) {
470          return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== "body";
471        });
472      }
473      function getClippingRect(element, boundary, rootBoundary, strategy) {
474        var mainClippingParents = boundary === "clippingParents" ? getClippingParents(element) : [].concat(boundary);
475        var clippingParents2 = [].concat(mainClippingParents, [rootBoundary]);
476        var firstClippingParent = clippingParents2[0];
477        var clippingRect = clippingParents2.reduce(function(accRect, clippingParent) {
478          var rect = getClientRectFromMixedType(element, clippingParent, strategy);
479          accRect.top = max(rect.top, accRect.top);
480          accRect.right = min(rect.right, accRect.right);
481          accRect.bottom = min(rect.bottom, accRect.bottom);
482          accRect.left = max(rect.left, accRect.left);
483          return accRect;
484        }, getClientRectFromMixedType(element, firstClippingParent, strategy));
485        clippingRect.width = clippingRect.right - clippingRect.left;
486        clippingRect.height = clippingRect.bottom - clippingRect.top;
487        clippingRect.x = clippingRect.left;
488        clippingRect.y = clippingRect.top;
489        return clippingRect;
490      }
491      function getBasePlacement(placement) {
492        return placement.split("-")[0];
493      }
494      function getVariation(placement) {
495        return placement.split("-")[1];
496      }
497      function getMainAxisFromPlacement(placement) {
498        return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y";
499      }
500      function computeOffsets(_ref) {
501        var reference2 = _ref.reference, element = _ref.element, placement = _ref.placement;
502        var basePlacement = placement ? getBasePlacement(placement) : null;
503        var variation = placement ? getVariation(placement) : null;
504        var commonX = reference2.x + reference2.width / 2 - element.width / 2;
505        var commonY = reference2.y + reference2.height / 2 - element.height / 2;
506        var offsets;
507        switch (basePlacement) {
508          case top:
509            offsets = {
510              x: commonX,
511              y: reference2.y - element.height
512            };
513            break;
514          case bottom:
515            offsets = {
516              x: commonX,
517              y: reference2.y + reference2.height
518            };
519            break;
520          case right:
521            offsets = {
522              x: reference2.x + reference2.width,
523              y: commonY
524            };
525            break;
526          case left:
527            offsets = {
528              x: reference2.x - element.width,
529              y: commonY
530            };
531            break;
532          default:
533            offsets = {
534              x: reference2.x,
535              y: reference2.y
536            };
537        }
538        var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
539        if (mainAxis != null) {
540          var len = mainAxis === "y" ? "height" : "width";
541          switch (variation) {
542            case start:
543              offsets[mainAxis] = offsets[mainAxis] - (reference2[len] / 2 - element[len] / 2);
544              break;
545            case end:
546              offsets[mainAxis] = offsets[mainAxis] + (reference2[len] / 2 - element[len] / 2);
547              break;
548          }
549        }
550        return offsets;
551      }
552      function getFreshSideObject() {
553        return {
554          top: 0,
555          right: 0,
556          bottom: 0,
557          left: 0
558        };
559      }
560      function mergePaddingObject(paddingObject) {
561        return Object.assign({}, getFreshSideObject(), paddingObject);
562      }
563      function expandToHashMap(value, keys) {
564        return keys.reduce(function(hashMap, key) {
565          hashMap[key] = value;
566          return hashMap;
567        }, {});
568      }
569      function detectOverflow(state, options) {
570        if (options === void 0) {
571          options = {};
572        }
573        var _options = options, _options$placement = _options.placement, placement = _options$placement === void 0 ? state.placement : _options$placement, _options$strategy = _options.strategy, strategy = _options$strategy === void 0 ? state.strategy : _options$strategy, _options$boundary = _options.boundary, boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, _options$rootBoundary = _options.rootBoundary, rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, _options$elementConte = _options.elementContext, elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, _options$altBoundary = _options.altBoundary, altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, _options$padding = _options.padding, padding = _options$padding === void 0 ? 0 : _options$padding;
574        var paddingObject = mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
575        var altContext = elementContext === popper ? reference : popper;
576        var popperRect = state.rects.popper;
577        var element = state.elements[altBoundary ? altContext : elementContext];
578        var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy);
579        var referenceClientRect = getBoundingClientRect(state.elements.reference);
580        var popperOffsets2 = computeOffsets({
581          reference: referenceClientRect,
582          element: popperRect,
583          strategy: "absolute",
584          placement
585        });
586        var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets2));
587        var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect;
588        var overflowOffsets = {
589          top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
590          bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
591          left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
592          right: elementClientRect.right - clippingClientRect.right + paddingObject.right
593        };
594        var offsetData = state.modifiersData.offset;
595        if (elementContext === popper && offsetData) {
596          var offset2 = offsetData[placement];
597          Object.keys(overflowOffsets).forEach(function(key) {
598            var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
599            var axis = [top, bottom].indexOf(key) >= 0 ? "y" : "x";
600            overflowOffsets[key] += offset2[axis] * multiply;
601          });
602        }
603        return overflowOffsets;
604      }
605      var DEFAULT_OPTIONS2 = {
606        placement: "bottom",
607        modifiers: [],
608        strategy: "absolute"
609      };
610      function areValidElements() {
611        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
612          args[_key] = arguments[_key];
613        }
614        return !args.some(function(element) {
615          return !(element && typeof element.getBoundingClientRect === "function");
616        });
617      }
618      function popperGenerator(generatorOptions) {
619        if (generatorOptions === void 0) {
620          generatorOptions = {};
621        }
622        var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers2 = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS2 : _generatorOptions$def2;
623        return function createPopper2(reference2, popper2, options) {
624          if (options === void 0) {
625            options = defaultOptions;
626          }
627          var state = {
628            placement: "bottom",
629            orderedModifiers: [],
630            options: Object.assign({}, DEFAULT_OPTIONS2, defaultOptions),
631            modifiersData: {},
632            elements: {
633              reference: reference2,
634              popper: popper2
635            },
636            attributes: {},
637            styles: {}
638          };
639          var effectCleanupFns = [];
640          var isDestroyed = false;
641          var instance = {
642            state,
643            setOptions: function setOptions(setOptionsAction) {
644              var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
645              cleanupModifierEffects();
646              state.options = Object.assign({}, defaultOptions, state.options, options2);
647              state.scrollParents = {
648                reference: isElement(reference2) ? listScrollParents(reference2) : reference2.contextElement ? listScrollParents(reference2.contextElement) : [],
649                popper: listScrollParents(popper2)
650              };
651              var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers2, state.options.modifiers)));
652              state.orderedModifiers = orderedModifiers.filter(function(m3) {
653                return m3.enabled;
654              });
655              runModifierEffects();
656              return instance.update();
657            },
658            // Sync update – it will always be executed, even if not necessary. This
659            // is useful for low frequency updates where sync behavior simplifies the
660            // logic.
661            // For high frequency updates (e.g. `resize` and `scroll` events), always
662            // prefer the async Popper#update method
663            forceUpdate: function forceUpdate() {
664              if (isDestroyed) {
665                return;
666              }
667              var _state$elements = state.elements, reference3 = _state$elements.reference, popper3 = _state$elements.popper;
668              if (!areValidElements(reference3, popper3)) {
669                return;
670              }
671              state.rects = {
672                reference: getCompositeRect(reference3, getOffsetParent(popper3), state.options.strategy === "fixed"),
673                popper: getLayoutRect(popper3)
674              };
675              state.reset = false;
676              state.placement = state.options.placement;
677              state.orderedModifiers.forEach(function(modifier) {
678                return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
679              });
680              for (var index = 0; index < state.orderedModifiers.length; index++) {
681                if (state.reset === true) {
682                  state.reset = false;
683                  index = -1;
684                  continue;
685                }
686                var _state$orderedModifie = state.orderedModifiers[index], fn = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name;
687                if (typeof fn === "function") {
688                  state = fn({
689                    state,
690                    options: _options,
691                    name,
692                    instance
693                  }) || state;
694                }
695              }
696            },
697            // Async and optimistically optimized update – it will not be executed if
698            // not necessary (debounced to run at most once-per-tick)
699            update: debounce(function() {
700              return new Promise(function(resolve) {
701                instance.forceUpdate();
702                resolve(state);
703              });
704            }),
705            destroy: function destroy() {
706              cleanupModifierEffects();
707              isDestroyed = true;
708            }
709          };
710          if (!areValidElements(reference2, popper2)) {
711            return instance;
712          }
713          instance.setOptions(options).then(function(state2) {
714            if (!isDestroyed && options.onFirstUpdate) {
715              options.onFirstUpdate(state2);
716            }
717          });
718          function runModifierEffects() {
719            state.orderedModifiers.forEach(function(_ref) {
720              var name = _ref.name, _ref$options = _ref.options, options2 = _ref$options === void 0 ? {} : _ref$options, effect2 = _ref.effect;
721              if (typeof effect2 === "function") {
722                var cleanupFn = effect2({
723                  state,
724                  name,
725                  instance,
726                  options: options2
727                });
728                var noopFn = function noopFn2() {
729                };
730                effectCleanupFns.push(cleanupFn || noopFn);
731              }
732            });
733          }
734          function cleanupModifierEffects() {
735            effectCleanupFns.forEach(function(fn) {
736              return fn();
737            });
738            effectCleanupFns = [];
739          }
740          return instance;
741        };
742      }
743      var passive = {
744        passive: true
745      };
746      function effect$2(_ref) {
747        var state = _ref.state, instance = _ref.instance, options = _ref.options;
748        var _options$scroll = options.scroll, scroll = _options$scroll === void 0 ? true : _options$scroll, _options$resize = options.resize, resize = _options$resize === void 0 ? true : _options$resize;
749        var window2 = getWindow(state.elements.popper);
750        var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
751        if (scroll) {
752          scrollParents.forEach(function(scrollParent) {
753            scrollParent.addEventListener("scroll", instance.update, passive);
754          });
755        }
756        if (resize) {
757          window2.addEventListener("resize", instance.update, passive);
758        }
759        return function() {
760          if (scroll) {
761            scrollParents.forEach(function(scrollParent) {
762              scrollParent.removeEventListener("scroll", instance.update, passive);
763            });
764          }
765          if (resize) {
766            window2.removeEventListener("resize", instance.update, passive);
767          }
768        };
769      }
770      var eventListeners = {
771        name: "eventListeners",
772        enabled: true,
773        phase: "write",
774        fn: function fn() {
775        },
776        effect: effect$2,
777        data: {}
778      };
779      function popperOffsets(_ref) {
780        var state = _ref.state, name = _ref.name;
781        state.modifiersData[name] = computeOffsets({
782          reference: state.rects.reference,
783          element: state.rects.popper,
784          strategy: "absolute",
785          placement: state.placement
786        });
787      }
788      var popperOffsets$1 = {
789        name: "popperOffsets",
790        enabled: true,
791        phase: "read",
792        fn: popperOffsets,
793        data: {}
794      };
795      var unsetSides = {
796        top: "auto",
797        right: "auto",
798        bottom: "auto",
799        left: "auto"
800      };
801      function roundOffsetsByDPR(_ref, win) {
802        var x2 = _ref.x, y3 = _ref.y;
803        var dpr = win.devicePixelRatio || 1;
804        return {
805          x: round(x2 * dpr) / dpr || 0,
806          y: round(y3 * dpr) / dpr || 0
807        };
808      }
809      function mapToStyles(_ref2) {
810        var _Object$assign2;
811        var popper2 = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, variation = _ref2.variation, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, isFixed = _ref2.isFixed;
812        var _offsets$x = offsets.x, x2 = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y3 = _offsets$y === void 0 ? 0 : _offsets$y;
813        var _ref3 = typeof roundOffsets === "function" ? roundOffsets({
814          x: x2,
815          y: y3
816        }) : {
817          x: x2,
818          y: y3
819        };
820        x2 = _ref3.x;
821        y3 = _ref3.y;
822        var hasX = offsets.hasOwnProperty("x");
823        var hasY = offsets.hasOwnProperty("y");
824        var sideX = left;
825        var sideY = top;
826        var win = window;
827        if (adaptive) {
828          var offsetParent = getOffsetParent(popper2);
829          var heightProp = "clientHeight";
830          var widthProp = "clientWidth";
831          if (offsetParent === getWindow(popper2)) {
832            offsetParent = getDocumentElement(popper2);
833            if (getComputedStyle2(offsetParent).position !== "static" && position === "absolute") {
834              heightProp = "scrollHeight";
835              widthProp = "scrollWidth";
836            }
837          }
838          offsetParent = offsetParent;
839          if (placement === top || (placement === left || placement === right) && variation === end) {
840            sideY = bottom;
841            var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : (
842              // $FlowFixMe[prop-missing]
843              offsetParent[heightProp]
844            );
845            y3 -= offsetY - popperRect.height;
846            y3 *= gpuAcceleration ? 1 : -1;
847          }
848          if (placement === left || (placement === top || placement === bottom) && variation === end) {
849            sideX = right;
850            var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : (
851              // $FlowFixMe[prop-missing]
852              offsetParent[widthProp]
853            );
854            x2 -= offsetX - popperRect.width;
855            x2 *= gpuAcceleration ? 1 : -1;
856          }
857        }
858        var commonStyles = Object.assign({
859          position
860        }, adaptive && unsetSides);
861        var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
862          x: x2,
863          y: y3
864        }, getWindow(popper2)) : {
865          x: x2,
866          y: y3
867        };
868        x2 = _ref4.x;
869        y3 = _ref4.y;
870        if (gpuAcceleration) {
871          var _Object$assign;
872          return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? "0" : "", _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x2 + "px, " + y3 + "px)" : "translate3d(" + x2 + "px, " + y3 + "px, 0)", _Object$assign));
873        }
874        return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y3 + "px" : "", _Object$assign2[sideX] = hasX ? x2 + "px" : "", _Object$assign2.transform = "", _Object$assign2));
875      }
876      function computeStyles(_ref5) {
877        var state = _ref5.state, options = _ref5.options;
878        var _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = _options$adaptive === void 0 ? true : _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
879        var commonStyles = {
880          placement: getBasePlacement(state.placement),
881          variation: getVariation(state.placement),
882          popper: state.elements.popper,
883          popperRect: state.rects.popper,
884          gpuAcceleration,
885          isFixed: state.options.strategy === "fixed"
886        };
887        if (state.modifiersData.popperOffsets != null) {
888          state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
889            offsets: state.modifiersData.popperOffsets,
890            position: state.options.strategy,
891            adaptive,
892            roundOffsets
893          })));
894        }
895        if (state.modifiersData.arrow != null) {
896          state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
897            offsets: state.modifiersData.arrow,
898            position: "absolute",
899            adaptive: false,
900            roundOffsets
901          })));
902        }
903        state.attributes.popper = Object.assign({}, state.attributes.popper, {
904          "data-popper-placement": state.placement
905        });
906      }
907      var computeStyles$1 = {
908        name: "computeStyles",
909        enabled: true,
910        phase: "beforeWrite",
911        fn: computeStyles,
912        data: {}
913      };
914      function applyStyles(_ref) {
915        var state = _ref.state;
916        Object.keys(state.elements).forEach(function(name) {
917          var style = state.styles[name] || {};
918          var attributes = state.attributes[name] || {};
919          var element = state.elements[name];
920          if (!isHTMLElement(element) || !getNodeName(element)) {
921            return;
922          }
923          Object.assign(element.style, style);
924          Object.keys(attributes).forEach(function(name2) {
925            var value = attributes[name2];
926            if (value === false) {
927              element.removeAttribute(name2);
928            } else {
929              element.setAttribute(name2, value === true ? "" : value);
930            }
931          });
932        });
933      }
934      function effect$1(_ref2) {
935        var state = _ref2.state;
936        var initialStyles = {
937          popper: {
938            position: state.options.strategy,
939            left: "0",
940            top: "0",
941            margin: "0"
942          },
943          arrow: {
944            position: "absolute"
945          },
946          reference: {}
947        };
948        Object.assign(state.elements.popper.style, initialStyles.popper);
949        state.styles = initialStyles;
950        if (state.elements.arrow) {
951          Object.assign(state.elements.arrow.style, initialStyles.arrow);
952        }
953        return function() {
954          Object.keys(state.elements).forEach(function(name) {
955            var element = state.elements[name];
956            var attributes = state.attributes[name] || {};
957            var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]);
958            var style = styleProperties.reduce(function(style2, property) {
959              style2[property] = "";
960              return style2;
961            }, {});
962            if (!isHTMLElement(element) || !getNodeName(element)) {
963              return;
964            }
965            Object.assign(element.style, style);
966            Object.keys(attributes).forEach(function(attribute) {
967              element.removeAttribute(attribute);
968            });
969          });
970        };
971      }
972      var applyStyles$1 = {
973        name: "applyStyles",
974        enabled: true,
975        phase: "write",
976        fn: applyStyles,
977        effect: effect$1,
978        requires: ["computeStyles"]
979      };
980      function distanceAndSkiddingToXY(placement, rects, offset2) {
981        var basePlacement = getBasePlacement(placement);
982        var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
983        var _ref = typeof offset2 === "function" ? offset2(Object.assign({}, rects, {
984          placement
985        })) : offset2, skidding = _ref[0], distance = _ref[1];
986        skidding = skidding || 0;
987        distance = (distance || 0) * invertDistance;
988        return [left, right].indexOf(basePlacement) >= 0 ? {
989          x: distance,
990          y: skidding
991        } : {
992          x: skidding,
993          y: distance
994        };
995      }
996      function offset(_ref2) {
997        var state = _ref2.state, options = _ref2.options, name = _ref2.name;
998        var _options$offset = options.offset, offset2 = _options$offset === void 0 ? [0, 0] : _options$offset;
999        var data = placements.reduce(function(acc, placement) {
1000          acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset2);
1001          return acc;
1002        }, {});
1003        var _data$state$placement = data[state.placement], x2 = _data$state$placement.x, y3 = _data$state$placement.y;
1004        if (state.modifiersData.popperOffsets != null) {
1005          state.modifiersData.popperOffsets.x += x2;
1006          state.modifiersData.popperOffsets.y += y3;
1007        }
1008        state.modifiersData[name] = data;
1009      }
1010      var offset$1 = {
1011        name: "offset",
1012        enabled: true,
1013        phase: "main",
1014        requires: ["popperOffsets"],
1015        fn: offset
1016      };
1017      var hash$1 = {
1018        left: "right",
1019        right: "left",
1020        bottom: "top",
1021        top: "bottom"
1022      };
1023      function getOppositePlacement(placement) {
1024        return placement.replace(/left|right|bottom|top/g, function(matched) {
1025          return hash$1[matched];
1026        });
1027      }
1028      var hash = {
1029        start: "end",
1030        end: "start"
1031      };
1032      function getOppositeVariationPlacement(placement) {
1033        return placement.replace(/start|end/g, function(matched) {
1034          return hash[matched];
1035        });
1036      }
1037      function computeAutoPlacement(state, options) {
1038        if (options === void 0) {
1039          options = {};
1040        }
1041        var _options = options, placement = _options.placement, boundary = _options.boundary, rootBoundary = _options.rootBoundary, padding = _options.padding, flipVariations = _options.flipVariations, _options$allowedAutoP = _options.allowedAutoPlacements, allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;
1042        var variation = getVariation(placement);
1043        var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function(placement2) {
1044          return getVariation(placement2) === variation;
1045        }) : basePlacements;
1046        var allowedPlacements = placements$1.filter(function(placement2) {
1047          return allowedAutoPlacements.indexOf(placement2) >= 0;
1048        });
1049        if (allowedPlacements.length === 0) {
1050          allowedPlacements = placements$1;
1051        }
1052        var overflows = allowedPlacements.reduce(function(acc, placement2) {
1053          acc[placement2] = detectOverflow(state, {
1054            placement: placement2,
1055            boundary,
1056            rootBoundary,
1057            padding
1058          })[getBasePlacement(placement2)];
1059          return acc;
1060        }, {});
1061        return Object.keys(overflows).sort(function(a8, b3) {
1062          return overflows[a8] - overflows[b3];
1063        });
1064      }
1065      function getExpandedFallbackPlacements(placement) {
1066        if (getBasePlacement(placement) === auto) {
1067          return [];
1068        }
1069        var oppositePlacement = getOppositePlacement(placement);
1070        return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
1071      }
1072      function flip(_ref) {
1073        var state = _ref.state, options = _ref.options, name = _ref.name;
1074        if (state.modifiersData[name]._skip) {
1075          return;
1076        }
1077        var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, specifiedFallbackPlacements = options.fallbackPlacements, padding = options.padding, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, _options$flipVariatio = options.flipVariations, flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, allowedAutoPlacements = options.allowedAutoPlacements;
1078        var preferredPlacement = state.options.placement;
1079        var basePlacement = getBasePlacement(preferredPlacement);
1080        var isBasePlacement = basePlacement === preferredPlacement;
1081        var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
1082        var placements2 = [preferredPlacement].concat(fallbackPlacements).reduce(function(acc, placement2) {
1083          return acc.concat(getBasePlacement(placement2) === auto ? computeAutoPlacement(state, {
1084            placement: placement2,
1085            boundary,
1086            rootBoundary,
1087            padding,
1088            flipVariations,
1089            allowedAutoPlacements
1090          }) : placement2);
1091        }, []);
1092        var referenceRect = state.rects.reference;
1093        var popperRect = state.rects.popper;
1094        var checksMap = /* @__PURE__ */ new Map();
1095        var makeFallbackChecks = true;
1096        var firstFittingPlacement = placements2[0];
1097        for (var i10 = 0; i10 < placements2.length; i10++) {
1098          var placement = placements2[i10];
1099          var _basePlacement = getBasePlacement(placement);
1100          var isStartVariation = getVariation(placement) === start;
1101          var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;
1102          var len = isVertical ? "width" : "height";
1103          var overflow = detectOverflow(state, {
1104            placement,
1105            boundary,
1106            rootBoundary,
1107            altBoundary,
1108            padding
1109          });
1110          var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
1111          if (referenceRect[len] > popperRect[len]) {
1112            mainVariationSide = getOppositePlacement(mainVariationSide);
1113          }
1114          var altVariationSide = getOppositePlacement(mainVariationSide);
1115          var checks = [];
1116          if (checkMainAxis) {
1117            checks.push(overflow[_basePlacement] <= 0);
1118          }
1119          if (checkAltAxis) {
1120            checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
1121          }
1122          if (checks.every(function(check) {
1123            return check;
1124          })) {
1125            firstFittingPlacement = placement;
1126            makeFallbackChecks = false;
1127            break;
1128          }
1129          checksMap.set(placement, checks);
1130        }
1131        if (makeFallbackChecks) {
1132          var numberOfChecks = flipVariations ? 3 : 1;
1133          var _loop = function _loop2(_i3) {
1134            var fittingPlacement = placements2.find(function(placement2) {
1135              var checks2 = checksMap.get(placement2);
1136              if (checks2) {
1137                return checks2.slice(0, _i3).every(function(check) {
1138                  return check;
1139                });
1140              }
1141            });
1142            if (fittingPlacement) {
1143              firstFittingPlacement = fittingPlacement;
1144              return "break";
1145            }
1146          };
1147          for (var _i2 = numberOfChecks; _i2 > 0; _i2--) {
1148            var _ret = _loop(_i2);
1149            if (_ret === "break") break;
1150          }
1151        }
1152        if (state.placement !== firstFittingPlacement) {
1153          state.modifiersData[name]._skip = true;
1154          state.placement = firstFittingPlacement;
1155          state.reset = true;
1156        }
1157      }
1158      var flip$1 = {
1159        name: "flip",
1160        enabled: true,
1161        phase: "main",
1162        fn: flip,
1163        requiresIfExists: ["offset"],
1164        data: {
1165          _skip: false
1166        }
1167      };
1168      function getAltAxis(axis) {
1169        return axis === "x" ? "y" : "x";
1170      }
1171      function within(min$1, value, max$1) {
1172        return max(min$1, min(value, max$1));
1173      }
1174      function withinMaxClamp(min2, value, max2) {
1175        var v3 = within(min2, value, max2);
1176        return v3 > max2 ? max2 : v3;
1177      }
1178      function preventOverflow(_ref) {
1179        var state = _ref.state, options = _ref.options, name = _ref.name;
1180        var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, padding = options.padding, _options$tether = options.tether, tether = _options$tether === void 0 ? true : _options$tether, _options$tetherOffset = options.tetherOffset, tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
1181        var overflow = detectOverflow(state, {
1182          boundary,
1183          rootBoundary,
1184          padding,
1185          altBoundary
1186        });
1187        var basePlacement = getBasePlacement(state.placement);
1188        var variation = getVariation(state.placement);
1189        var isBasePlacement = !variation;
1190        var mainAxis = getMainAxisFromPlacement(basePlacement);
1191        var altAxis = getAltAxis(mainAxis);
1192        var popperOffsets2 = state.modifiersData.popperOffsets;
1193        var referenceRect = state.rects.reference;
1194        var popperRect = state.rects.popper;
1195        var tetherOffsetValue = typeof tetherOffset === "function" ? tetherOffset(Object.assign({}, state.rects, {
1196          placement: state.placement
1197        })) : tetherOffset;
1198        var normalizedTetherOffsetValue = typeof tetherOffsetValue === "number" ? {
1199          mainAxis: tetherOffsetValue,
1200          altAxis: tetherOffsetValue
1201        } : Object.assign({
1202          mainAxis: 0,
1203          altAxis: 0
1204        }, tetherOffsetValue);
1205        var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
1206        var data = {
1207          x: 0,
1208          y: 0
1209        };
1210        if (!popperOffsets2) {
1211          return;
1212        }
1213        if (checkMainAxis) {
1214          var _offsetModifierState$;
1215          var mainSide = mainAxis === "y" ? top : left;
1216          var altSide = mainAxis === "y" ? bottom : right;
1217          var len = mainAxis === "y" ? "height" : "width";
1218          var offset2 = popperOffsets2[mainAxis];
1219          var min$1 = offset2 + overflow[mainSide];
1220          var max$1 = offset2 - overflow[altSide];
1221          var additive = tether ? -popperRect[len] / 2 : 0;
1222          var minLen = variation === start ? referenceRect[len] : popperRect[len];
1223          var maxLen = variation === start ? -popperRect[len] : -referenceRect[len];
1224          var arrowElement = state.elements.arrow;
1225          var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
1226            width: 0,
1227            height: 0
1228          };
1229          var arrowPaddingObject = state.modifiersData["arrow#persistent"] ? state.modifiersData["arrow#persistent"].padding : getFreshSideObject();
1230          var arrowPaddingMin = arrowPaddingObject[mainSide];
1231          var arrowPaddingMax = arrowPaddingObject[altSide];
1232          var arrowLen = within(0, referenceRect[len], arrowRect[len]);
1233          var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
1234          var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
1235          var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
1236          var clientOffset = arrowOffsetParent ? mainAxis === "y" ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
1237          var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
1238          var tetherMin = offset2 + minOffset - offsetModifierValue - clientOffset;
1239          var tetherMax = offset2 + maxOffset - offsetModifierValue;
1240          var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset2, tether ? max(max$1, tetherMax) : max$1);
1241          popperOffsets2[mainAxis] = preventedOffset;
1242          data[mainAxis] = preventedOffset - offset2;
1243        }
1244        if (checkAltAxis) {
1245          var _offsetModifierState$2;
1246          var _mainSide = mainAxis === "x" ? top : left;
1247          var _altSide = mainAxis === "x" ? bottom : right;
1248          var _offset = popperOffsets2[altAxis];
1249          var _len = altAxis === "y" ? "height" : "width";
1250          var _min = _offset + overflow[_mainSide];
1251          var _max = _offset - overflow[_altSide];
1252          var isOriginSide = [top, left].indexOf(basePlacement) !== -1;
1253          var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
1254          var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
1255          var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
1256          var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
1257          popperOffsets2[altAxis] = _preventedOffset;
1258          data[altAxis] = _preventedOffset - _offset;
1259        }
1260        state.modifiersData[name] = data;
1261      }
1262      var preventOverflow$1 = {
1263        name: "preventOverflow",
1264        enabled: true,
1265        phase: "main",
1266        fn: preventOverflow,
1267        requiresIfExists: ["offset"]
1268      };
1269      var toPaddingObject = function toPaddingObject2(padding, state) {
1270        padding = typeof padding === "function" ? padding(Object.assign({}, state.rects, {
1271          placement: state.placement
1272        })) : padding;
1273        return mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
1274      };
1275      function arrow(_ref) {
1276        var _state$modifiersData$;
1277        var state = _ref.state, name = _ref.name, options = _ref.options;
1278        var arrowElement = state.elements.arrow;
1279        var popperOffsets2 = state.modifiersData.popperOffsets;
1280        var basePlacement = getBasePlacement(state.placement);
1281        var axis = getMainAxisFromPlacement(basePlacement);
1282        var isVertical = [left, right].indexOf(basePlacement) >= 0;
1283        var len = isVertical ? "height" : "width";
1284        if (!arrowElement || !popperOffsets2) {
1285          return;
1286        }
1287        var paddingObject = toPaddingObject(options.padding, state);
1288        var arrowRect = getLayoutRect(arrowElement);
1289        var minProp = axis === "y" ? top : left;
1290        var maxProp = axis === "y" ? bottom : right;
1291        var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets2[axis] - state.rects.popper[len];
1292        var startDiff = popperOffsets2[axis] - state.rects.reference[axis];
1293        var arrowOffsetParent = getOffsetParent(arrowElement);
1294        var clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
1295        var centerToReference = endDiff / 2 - startDiff / 2;
1296        var min2 = paddingObject[minProp];
1297        var max2 = clientSize - arrowRect[len] - paddingObject[maxProp];
1298        var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
1299        var offset2 = within(min2, center, max2);
1300        var axisProp = axis;
1301        state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset2, _state$modifiersData$.centerOffset = offset2 - center, _state$modifiersData$);
1302      }
1303      function effect(_ref2) {
1304        var state = _ref2.state, options = _ref2.options;
1305        var _options$element = options.element, arrowElement = _options$element === void 0 ? "[data-popper-arrow]" : _options$element;
1306        if (arrowElement == null) {
1307          return;
1308        }
1309        if (typeof arrowElement === "string") {
1310          arrowElement = state.elements.popper.querySelector(arrowElement);
1311          if (!arrowElement) {
1312            return;
1313          }
1314        }
1315        if (!contains(state.elements.popper, arrowElement)) {
1316          return;
1317        }
1318        state.elements.arrow = arrowElement;
1319      }
1320      var arrow$1 = {
1321        name: "arrow",
1322        enabled: true,
1323        phase: "main",
1324        fn: arrow,
1325        effect,
1326        requires: ["popperOffsets"],
1327        requiresIfExists: ["preventOverflow"]
1328      };
1329      function getSideOffsets(overflow, rect, preventedOffsets) {
1330        if (preventedOffsets === void 0) {
1331          preventedOffsets = {
1332            x: 0,
1333            y: 0
1334          };
1335        }
1336        return {
1337          top: overflow.top - rect.height - preventedOffsets.y,
1338          right: overflow.right - rect.width + preventedOffsets.x,
1339          bottom: overflow.bottom - rect.height + preventedOffsets.y,
1340          left: overflow.left - rect.width - preventedOffsets.x
1341        };
1342      }
1343      function isAnySideFullyClipped(overflow) {
1344        return [top, right, bottom, left].some(function(side) {
1345          return overflow[side] >= 0;
1346        });
1347      }
1348      function hide(_ref) {
1349        var state = _ref.state, name = _ref.name;
1350        var referenceRect = state.rects.reference;
1351        var popperRect = state.rects.popper;
1352        var preventedOffsets = state.modifiersData.preventOverflow;
1353        var referenceOverflow = detectOverflow(state, {
1354          elementContext: "reference"
1355        });
1356        var popperAltOverflow = detectOverflow(state, {
1357          altBoundary: true
1358        });
1359        var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
1360        var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
1361        var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
1362        var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
1363        state.modifiersData[name] = {
1364          referenceClippingOffsets,
1365          popperEscapeOffsets,
1366          isReferenceHidden,
1367          hasPopperEscaped
1368        };
1369        state.attributes.popper = Object.assign({}, state.attributes.popper, {
1370          "data-popper-reference-hidden": isReferenceHidden,
1371          "data-popper-escaped": hasPopperEscaped
1372        });
1373      }
1374      var hide$1 = {
1375        name: "hide",
1376        enabled: true,
1377        phase: "main",
1378        requiresIfExists: ["preventOverflow"],
1379        fn: hide
1380      };
1381      var defaultModifiers$1 = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1];
1382      var createPopper$1 = /* @__PURE__ */ popperGenerator({
1383        defaultModifiers: defaultModifiers$1
1384      });
1385      var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1];
1386      var createPopper = /* @__PURE__ */ popperGenerator({
1387        defaultModifiers
1388      });
1389      exports.applyStyles = applyStyles$1;
1390      exports.arrow = arrow$1;
1391      exports.computeStyles = computeStyles$1;
1392      exports.createPopper = createPopper;
1393      exports.createPopperLite = createPopper$1;
1394      exports.defaultModifiers = defaultModifiers;
1395      exports.detectOverflow = detectOverflow;
1396      exports.eventListeners = eventListeners;
1397      exports.flip = flip$1;
1398      exports.hide = hide$1;
1399      exports.offset = offset$1;
1400      exports.popperGenerator = popperGenerator;
1401      exports.popperOffsets = popperOffsets$1;
1402      exports.preventOverflow = preventOverflow$1;
1403    }
1404  });
1405
1406  

1406// node_modules/bootstrap/dist/js/bootstrap.js
1407  var require_bootstrap = __commonJS({
1408    "node_modules/bootstrap/dist/js/bootstrap.js"(exports, module) {
1409      (function(global, factory) {
1410        typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory(require_popper()) : typeof define === "function" && define.amd ? define(["@popperjs/core"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, global.bootstrap = factory(global.Popper));
1411      })(exports, (function(Popper) {
1412        "use strict";
1413        function _interopNamespaceDefault(e11) {
1414          const n10 = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
1415          if (e11) {
1416            for (const k3 in e11) {
1417              if (k3 !== "default") {
1418                const d3 = Object.getOwnPropertyDescriptor(e11, k3);
1419                Object.defineProperty(n10, k3, d3.get ? d3 : {
1420                  enumerable: true,
1421                  get: () => e11[k3]
1422                });
1423              }
1424            }
1425          }
1426          n10.default = e11;
1427          return Object.freeze(n10);
1428        }
1429        const Popper__namespace = /* @__PURE__ */ _interopNamespaceDefault(Popper);
1430        const elementMap = /* @__PURE__ */ new Map();
1431        const Data = {
1432          set(element, key, instance) {
1433            if (!elementMap.has(element)) {
1434              elementMap.set(element, /* @__PURE__ */ new Map());
1435            }
1436            const instanceMap = elementMap.get(element);
1437            if (!instanceMap.has(key) && instanceMap.size !== 0) {
1438              console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);
1439              return;
1440            }
1441            instanceMap.set(key, instance);
1442          },
1443          get(element, key) {
1444            if (elementMap.has(element)) {
1445              return elementMap.get(element).get(key) || null;
1446            }
1447            return null;
1448          },
1449          remove(element, key) {
1450            if (!elementMap.has(element)) {
1451              return;
1452            }
1453            const instanceMap = elementMap.get(element);
1454            instanceMap.delete(key);
1455            if (instanceMap.size === 0) {
1456              elementMap.delete(element);
1457            }
1458          }
1459        };
1460        const MAX_UID = 1e6;
1461        const MILLISECONDS_MULTIPLIER = 1e3;
1462        const TRANSITION_END = "transitionend";
1463        const parseSelector = (selector3) => {
1464          if (selector3 && window.CSS && window.CSS.escape) {
1465            selector3 = selector3.replace(/#([^\s"#']+)/g, (match, id) => `#${CSS.escape(id)}`);
1466          }
1467          return selector3;
1468        };
1469        const toType = (object) => {
1470          if (object === null || object === void 0) {
1471            return `${object}`;
1472          }
1473          return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase();
1474        };
1475        const getUID = (prefix) => {
1476          do {
1477            prefix += Math.floor(Math.random() * MAX_UID);
1478          } while (document.getElementById(prefix));
1479          return prefix;
1480        };
1481        const getTransitionDurationFromElement = (element) => {
1482          if (!element) {
1483            return 0;
1484          }
1485          let {
1486            transitionDuration,
1487            transitionDelay
1488          } = window.getComputedStyle(element);
1489          const floatTransitionDuration = Number.parseFloat(transitionDuration);
1490          const floatTransitionDelay = Number.parseFloat(transitionDelay);
1491          if (!floatTransitionDuration && !floatTransitionDelay) {
1492            return 0;
1493          }
1494          transitionDuration = transitionDuration.split(",")[0];
1495          transitionDelay = transitionDelay.split(",")[0];
1496          return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
1497        };
1498        const triggerTransitionEnd = (element) => {
1499          element.dispatchEvent(new Event(TRANSITION_END));
1500        };
1501        const isElement = (object) => {
1502          if (!object || typeof object !== "object") {
1503            return false;
1504          }
1505          if (typeof object.jquery !== "undefined") {
1506            object = object[0];
1507          }
1508          return typeof object.nodeType !== "undefined";
1509        };
1510        const getElement = (object) => {
1511          if (isElement(object)) {
1512            return object.jquery ? object[0] : object;
1513          }
1514          if (typeof object === "string" && object.length > 0) {
1515            return document.querySelector(parseSelector(object));
1516          }
1517          return null;
1518        };
1519        const isVisible = (element) => {
1520          if (!isElement(element) || element.getClientRects().length === 0) {
1521            return false;
1522          }
1523          const elementIsVisible = getComputedStyle(element).getPropertyValue("visibility") === "visible";
1524          const closedDetails = element.closest("details:not([open])");
1525          if (!closedDetails) {
1526            return elementIsVisible;
1527          }
1528          if (closedDetails !== element) {
1529            const summary = element.closest("summary");
1530            if (summary && summary.parentNode !== closedDetails) {
1531              return false;
1532            }
1533            if (summary === null) {
1534              return false;
1535            }
1536          }
1537          return elementIsVisible;
1538        };
1539        const isDisabled = (element) => {
1540          if (!element || element.nodeType !== Node.ELEMENT_NODE) {
1541            return true;
1542          }
1543          if (element.classList.contains("disabled")) {
1544            return true;
1545          }
1546          if (typeof element.disabled !== "undefined") {
1547            return element.disabled;
1548          }
1549          return element.hasAttribute("disabled") && element.getAttribute("disabled") !== "false";
1550        };
1551        const findShadowRoot = (element) => {
1552          if (!document.documentElement.attachShadow) {
1553            return null;
1554          }
1555          if (typeof element.getRootNode === "function") {
1556            const root = element.getRootNode();
1557            return root instanceof ShadowRoot ? root : null;
1558          }
1559          if (element instanceof ShadowRoot) {
1560            return element;
1561          }
1562          if (!element.parentNode) {
1563            return null;
1564          }
1565          return findShadowRoot(element.parentNode);
1566        };
1567        const noop = () => {
1568        };
1569        const reflow = (element) => {
1570          element.offsetHeight;
1571        };
1572        const getjQuery = () => {
1573          if (window.jQuery && !document.body.hasAttribute("data-bs-no-jquery")) {
1574            return window.jQuery;
1575          }
1576          return null;
1577        };
1578        const DOMContentLoadedCallbacks = [];
1579        const onDOMContentLoaded = (callback) => {
1580          if (document.readyState === "loading") {
1581            if (!DOMContentLoadedCallbacks.length) {
1582              document.addEventListener("DOMContentLoaded", () => {
1583                for (const callback2 of DOMContentLoadedCallbacks) {
1584                  callback2();
1585                }
1586              });
1587            }
1588            DOMContentLoadedCallbacks.push(callback);
1589          } else {
1590            callback();
1591          }
1592        };
1593        const isRTL = () => document.documentElement.dir === "rtl";
1594        const defineJQueryPlugin = (plugin) => {
1595          onDOMContentLoaded(() => {
1596            const $4 = getjQuery();
1597            if ($4) {
1598              const name = plugin.NAME;
1599              const JQUERY_NO_CONFLICT = $4.fn[name];
1600              $4.fn[name] = plugin.jQueryInterface;
1601              $4.fn[name].Constructor = plugin;
1602              $4.fn[name].noConflict = () => {
1603                $4.fn[name] = JQUERY_NO_CONFLICT;
1604                return plugin.jQueryInterface;
1605              };
1606            }
1607          });
1608        };
1609        const execute2 = (possibleCallback, args = [], defaultValue = possibleCallback) => {
1610          return typeof possibleCallback === "function" ? possibleCallback.call(...args) : defaultValue;
1611        };
1612        const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
1613          if (!waitForTransition) {
1614            execute2(callback);
1615            return;
1616          }
1617          const durationPadding = 5;
1618          const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
1619          let called = false;
1620          const handler = ({
1621            target
1622          }) => {
1623            if (target !== transitionElement) {
1624              return;
1625            }
1626            called = true;
1627            transitionElement.removeEventListener(TRANSITION_END, handler);
1628            execute2(callback);
1629          };
1630          transitionElement.addEventListener(TRANSITION_END, handler);
1631          setTimeout(() => {
1632            if (!called) {
1633              triggerTransitionEnd(transitionElement);
1634            }
1635          }, emulatedDuration);
1636        };
1637        const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
1638          const listLength = list.length;
1639          let index = list.indexOf(activeElement);
1640          if (index === -1) {
1641            return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];
1642          }
1643          index += shouldGetNext ? 1 : -1;
1644          if (isCycleAllowed) {
1645            index = (index + listLength) % listLength;
1646          }
1647          return list[Math.max(0, Math.min(index, listLength - 1))];
1648        };
1649        const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
1650        const stripNameRegex = /\..*/;
1651        const stripUidRegex = /::\d+$/;
1652        const eventRegistry = {};
1653        let uidEvent = 1;
1654        const customEvents = {
1655          mouseenter: "mouseover",
1656          mouseleave: "mouseout"
1657        };
1658        const nativeEvents = /* @__PURE__ */ 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"]);
1659        function makeEventUid(element, uid) {
1660          return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
1661        }
1662        function getElementEvents(element) {
1663          const uid = makeEventUid(element);
1664          element.uidEvent = uid;
1665          eventRegistry[uid] = eventRegistry[uid] || {};
1666          return eventRegistry[uid];
1667        }
1668        function bootstrapHandler(element, fn) {
1669          return function handler(event) {
1670            hydrateObj(event, {
1671              delegateTarget: element
1672            });
1673            if (handler.oneOff) {
1674              EventHandler.off(element, event.type, fn);
1675            }
1676            return fn.apply(element, [event]);
1677          };
1678        }
1679        function bootstrapDelegationHandler(element, selector3, fn) {
1680          return function handler(event) {
1681            const domElements = element.querySelectorAll(selector3);
1682            for (let {
1683              target
1684            } = event; target && target !== this; target = target.parentNode) {
1685              for (const domElement of domElements) {
1686                if (domElement !== target) {
1687                  continue;
1688                }
1689                hydrateObj(event, {
1690                  delegateTarget: target
1691                });
1692                if (handler.oneOff) {
1693                  EventHandler.off(element, event.type, selector3, fn);
1694                }
1695                return fn.apply(target, [event]);
1696              }
1697            }
1698          };
1699        }
1700        function findHandler(events, callable, delegationSelector = null) {
1701          return Object.values(events).find((event) => event.callable === callable && event.delegationSelector === delegationSelector);
1702        }
1703        function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
1704          const isDelegated = typeof handler === "string";
1705          const callable = isDelegated ? delegationFunction : handler || delegationFunction;
1706          let typeEvent = getTypeEvent(originalTypeEvent);
1707          if (!nativeEvents.has(typeEvent)) {
1708            typeEvent = originalTypeEvent;
1709          }
1710          return [isDelegated, callable, typeEvent];
1711        }
1712        function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
1713          if (typeof originalTypeEvent !== "string" || !element) {
1714            return;
1715          }
1716          let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
1717          if (originalTypeEvent in customEvents) {
1718            const wrapFunction = (fn2) => {
1719              return function(event) {
1720                if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
1721                  return fn2.call(this, event);
1722                }
1723              };
1724            };
1725            callable = wrapFunction(callable);
1726          }
1727          const events = getElementEvents(element);
1728          const handlers = events[typeEvent] || (events[typeEvent] = {});
1729          const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
1730          if (previousFunction) {
1731            previousFunction.oneOff = previousFunction.oneOff && oneOff;
1732            return;
1733          }
1734          const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ""));
1735          const fn = isDelegated ? bootstrapDelegationHandler(element, handler, callable) : bootstrapHandler(element, callable);
1736          fn.delegationSelector = isDelegated ? handler : null;
1737          fn.callable = callable;
1738          fn.oneOff = oneOff;
1739          fn.uidEvent = uid;
1740          handlers[uid] = fn;
1741          element.addEventListener(typeEvent, fn, isDelegated);
1742        }
1743        function removeHandler(element, events, typeEvent, handler, delegationSelector) {
1744          const fn = findHandler(events[typeEvent], handler, delegationSelector);
1745          if (!fn) {
1746            return;
1747          }
1748          element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
1749          delete events[typeEvent][fn.uidEvent];
1750        }
1751        function removeNamespacedHandlers(element, events, typeEvent, namespace) {
1752          const storeElementEvent = events[typeEvent] || {};
1753          for (const [handlerKey, event] of Object.entries(storeElementEvent)) {
1754            if (handlerKey.includes(namespace)) {
1755              removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
1756            }
1757          }
1758        }
1759        function getTypeEvent(event) {
1760          event = event.replace(stripNameRegex, "");
1761          return customEvents[event] || event;
1762        }
1763        const EventHandler = {
1764          on(element, event, handler, delegationFunction) {
1765            addHandler(element, event, handler, delegationFunction, false);
1766          },
1767          one(element, event, handler, delegationFunction) {
1768            addHandler(element, event, handler, delegationFunction, true);
1769          },
1770          off(element, originalTypeEvent, handler, delegationFunction) {
1771            if (typeof originalTypeEvent !== "string" || !element) {
1772              return;
1773            }
1774            const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
1775            const inNamespace = typeEvent !== originalTypeEvent;
1776            const events = getElementEvents(element);
1777            const storeElementEvent = events[typeEvent] || {};
1778            const isNamespace = originalTypeEvent.startsWith(".");
1779            if (typeof callable !== "undefined") {
1780              if (!Object.keys(storeElementEvent).length) {
1781                return;
1782              }
1783              removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
1784              return;
1785            }
1786            if (isNamespace) {
1787              for (const elementEvent of Object.keys(events)) {
1788                removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
1789              }
1790            }
1791            for (const [keyHandlers, event] of Object.entries(storeElementEvent)) {
1792              const handlerKey = keyHandlers.replace(stripUidRegex, "");
1793              if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
1794                removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
1795              }
1796            }
1797          },
1798          trigger(element, event, args) {
1799            if (typeof event !== "string" || !element) {
1800              return null;
1801            }
1802            const $4 = getjQuery();
1803            const typeEvent = getTypeEvent(event);
1804            const inNamespace = event !== typeEvent;
1805            let jQueryEvent = null;
1806            let bubbles = true;
1807            let nativeDispatch = true;
1808            let defaultPrevented = false;
1809            if (inNamespace && $4) {
1810              jQueryEvent = $4.Event(event, args);
1811              $4(element).trigger(jQueryEvent);
1812              bubbles = !jQueryEvent.isPropagationStopped();
1813              nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
1814              defaultPrevented = jQueryEvent.isDefaultPrevented();
1815            }
1816            const evt = hydrateObj(new Event(event, {
1817              bubbles,
1818              cancelable: true
1819            }), args);
1820            if (defaultPrevented) {
1821              evt.preventDefault();
1822            }
1823            if (nativeDispatch) {
1824              element.dispatchEvent(evt);
1825            }
1826            if (evt.defaultPrevented && jQueryEvent) {
1827              jQueryEvent.preventDefault();
1828            }
1829            return evt;
1830          }
1831        };
1832        function hydrateObj(obj, meta = {}) {
1833          for (const [key, value] of Object.entries(meta)) {
1834            try {
1835              obj[key] = value;
1836            } catch (_unused) {
1837              Object.defineProperty(obj, key, {
1838                configurable: true,
1839                get() {
1840                  return value;
1841                }
1842              });
1843            }
1844          }
1845          return obj;
1846        }
1847        function normalizeData(value) {
1848          if (value === "true") {
1849            return true;
1850          }
1851          if (value === "false") {
1852            return false;
1853          }
1854          if (value === Number(value).toString()) {
1855            return Number(value);
1856          }
1857          if (value === "" || value === "null") {
1858            return null;
1859          }
1860          if (typeof value !== "string") {
1861            return value;
1862          }
1863          try {
1864            return JSON.parse(decodeURIComponent(value));
1865          } catch (_unused) {
1866            return value;
1867          }
1868        }
1869        function normalizeDataKey(key) {
1870          return key.replace(/[A-Z]/g, (chr) => `-${chr.toLowerCase()}`);
1871        }
1872        const Manipulator = {
1873          setDataAttribute(element, key, value) {
1874            element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);
1875          },
1876          removeDataAttribute(element, key) {
1877            element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);
1878          },
1879          getDataAttributes(element) {
1880            if (!element) {
1881              return {};
1882            }
1883            const attributes = {};
1884            const bsKeys = Object.keys(element.dataset).filter((key) => key.startsWith("bs") && !key.startsWith("bsConfig"));
1885            for (const key of bsKeys) {
1886              let pureKey = key.replace(/^bs/, "");
1887              pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1);
1888              attributes[pureKey] = normalizeData(element.dataset[key]);
1889            }
1890            return attributes;
1891          },
1892          getDataAttribute(element, key) {
1893            return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
1894          }
1895        };
1896        class Config {
1897          // Getters
1898          static get Default() {
1899            return {};
1900          }
1901          static get DefaultType() {
1902            return {};
1903          }
1904          static get NAME() {
1905            throw new Error('You have to implement the static method "NAME", for each component!');
1906          }
1907          _getConfig(config3) {
1908            config3 = this._mergeConfigObj(config3);
1909            config3 = this._configAfterMerge(config3);
1910            this._typeCheckConfig(config3);
1911            return config3;
1912          }
1913          _configAfterMerge(config3) {
1914            return config3;
1915          }
1916          _mergeConfigObj(config3, element) {
1917            const jsonConfig = isElement(element) ? Manipulator.getDataAttribute(element, "config") : {};
1918            return {
1919              ...this.constructor.Default,
1920              ...typeof jsonConfig === "object" ? jsonConfig : {},
1921              ...isElement(element) ? Manipulator.getDataAttributes(element) : {},
1922              ...typeof config3 === "object" ? config3 : {}
1923            };
1924          }
1925          _typeCheckConfig(config3, configTypes = this.constructor.DefaultType) {
1926            for (const [property, expectedTypes] of Object.entries(configTypes)) {
1927              const value = config3[property];
1928              const valueType = isElement(value) ? "element" : toType(value);
1929              if (!new RegExp(expectedTypes).test(valueType)) {
1930                throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`);
1931              }
1932            }
1933          }
1934        }
1935        const VERSION = "5.3.8";
1936        class BaseComponent extends Config {
1937          constructor(element, config3) {
1938            super();
1939            element = getElement(element);
1940            if (!element) {
1941              return;
1942            }
1943            this._element = element;
1944            this._config = this._getConfig(config3);
1945            Data.set(this._element, this.constructor.DATA_KEY, this);
1946          }
1947          // Public
1948          dispose() {
1949            Data.remove(this._element, this.constructor.DATA_KEY);
1950            EventHandler.off(this._element, this.constructor.EVENT_KEY);
1951            for (const propertyName of Object.getOwnPropertyNames(this)) {
1952              this[propertyName] = null;
1953            }
1954          }
1955          // Private
1956          _queueCallback(callback, element, isAnimated = true) {
1957            executeAfterTransition(callback, element, isAnimated);
1958          }
1959          _getConfig(config3) {
1960            config3 = this._mergeConfigObj(config3, this._element);
1961            config3 = this._configAfterMerge(config3);
1962            this._typeCheckConfig(config3);
1963            return config3;
1964          }
1965          // Static
1966          static getInstance(element) {
1967            return Data.get(getElement(element), this.DATA_KEY);
1968          }
1969          static getOrCreateInstance(element, config3 = {}) {
1970            return this.getInstance(element) || new this(element, typeof config3 === "object" ? config3 : null);
1971          }
1972          static get VERSION() {
1973            return VERSION;
1974          }
1975          static get DATA_KEY() {
1976            return `bs.${this.NAME}`;
1977          }
1978          static get EVENT_KEY() {
1979            return `.${this.DATA_KEY}`;
1980          }
1981          static eventName(name) {
1982            return `${name}${this.EVENT_KEY}`;
1983          }
1984        }
1985        const getSelector = (element) => {
1986          let selector3 = element.getAttribute("data-bs-target");
1987          if (!selector3 || selector3 === "#") {
1988            let hrefAttribute = element.getAttribute("href");
1989            if (!hrefAttribute || !hrefAttribute.includes("#") && !hrefAttribute.startsWith(".")) {
1990              return null;
1991            }
1992            if (hrefAttribute.includes("#") && !hrefAttribute.startsWith("#")) {
1993              hrefAttribute = `#${hrefAttribute.split("#")[1]}`;
1994            }
1995            selector3 = hrefAttribute && hrefAttribute !== "#" ? hrefAttribute.trim() : null;
1996          }
1997          return selector3 ? selector3.split(",").map((sel) => parseSelector(sel)).join(",") : null;
1998        };
1999        const SelectorEngine = {
2000          find(selector3, element = document.documentElement) {
2001            return [].concat(...Element.prototype.querySelectorAll.call(element, selector3));
2002          },
2003          findOne(selector3, element = document.documentElement) {
2004            return Element.prototype.querySelector.call(element, selector3);
2005          },
2006          children(element, selector3) {
2007            return [].concat(...element.children).filter((child) => child.matches(selector3));
2008          },
2009          parents(element, selector3) {
2010            const parents = [];
2011            let ancestor = element.parentNode.closest(selector3);
2012            while (ancestor) {
2013              parents.push(ancestor);
2014              ancestor = ancestor.parentNode.closest(selector3);
2015            }
2016            return parents;
2017          },
2018          prev(element, selector3) {
2019            let previous = element.previousElementSibling;
2020            while (previous) {
2021              if (previous.matches(selector3)) {
2022                return [previous];
2023              }
2024              previous = previous.previousElementSibling;
2025            }
2026            return [];
2027          },
2028          // TODO: this is now unused; remove later along with prev()
2029          next(element, selector3) {
2030            let next = element.nextElementSibling;
2031            while (next) {
2032              if (next.matches(selector3)) {
2033                return [next];
2034              }
2035              next = next.nextElementSibling;
2036            }
2037            return [];
2038          },
2039          focusableChildren(element) {
2040            const focusables = ["a", "button", "input", "textarea", "select", "details", "[tabindex]", '[contenteditable="true"]'].map((selector3) => `${selector3}:not([tabindex^="-"])`).join(",");
2041            return this.find(focusables, element).filter((el) => !isDisabled(el) && isVisible(el));
2042          },
2043          getSelectorFromElement(element) {
2044            const selector3 = getSelector(element);
2045            if (selector3) {
2046              return SelectorEngine.findOne(selector3) ? selector3 : null;
2047            }
2048            return null;
2049          },
2050          getElementFromSelector(element) {
2051            const selector3 = getSelector(element);
2052            return selector3 ? SelectorEngine.findOne(selector3) : null;
2053          },
2054          getMultipleElementsFromSelector(element) {
2055            const selector3 = getSelector(element);
2056            return selector3 ? SelectorEngine.find(selector3) : [];
2057          }
2058        };
2059        const enableDismissTrigger = (component, method = "hide") => {
2060          const clickEvent = `click.dismiss${component.EVENT_KEY}`;
2061          const name = component.NAME;
2062          EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function(event) {
2063            if (["A", "AREA"].includes(this.tagName)) {
2064              event.preventDefault();
2065            }
2066            if (isDisabled(this)) {
2067              return;
2068            }
2069            const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`);
2070            const instance = component.getOrCreateInstance(target);
2071            instance[method]();
2072          });
2073        };
2074        const NAME$f = "alert";
2075        const DATA_KEY$a = "bs.alert";
2076        const EVENT_KEY$b = `.${DATA_KEY$a}`;
2077        const EVENT_CLOSE = `close${EVENT_KEY$b}`;
2078        const EVENT_CLOSED = `closed${EVENT_KEY$b}`;
2079        const CLASS_NAME_FADE$5 = "fade";
2080        const CLASS_NAME_SHOW$8 = "show";
2081        class Alert extends BaseComponent {
2082          // Getters
2083          static get NAME() {
2084            return NAME$f;
2085          }
2086          // Public
2087          close() {
2088            const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
2089            if (closeEvent.defaultPrevented) {
2090              return;
2091            }
2092            this._element.classList.remove(CLASS_NAME_SHOW$8);
2093            const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
2094            this._queueCallback(() => this._destroyElement(), this._element, isAnimated);
2095          }
2096          // Private
2097          _destroyElement() {
2098            this._element.remove();
2099            EventHandler.trigger(this._element, EVENT_CLOSED);
2100            this.dispose();
2101          }
2102          // Static
2103          static jQueryInterface(config3) {
2104            return this.each(function() {
2105              const data = Alert.getOrCreateInstance(this);
2106              if (typeof config3 !== "string") {
2107                return;
2108              }
2109              if (data[config3] === void 0 || config3.startsWith("_") || config3 === "constructor") {
2110                throw new TypeError(`No method named "${config3}"`);
2111              }
2112              data[config3](this);
2113            });
2114          }
2115        }
2116        enableDismissTrigger(Alert, "close");
2117        defineJQueryPlugin(Alert);
2118        const NAME$e = "button";
2119        const DATA_KEY$9 = "bs.button";
2120        const EVENT_KEY$a = `.${DATA_KEY$9}`;
2121        const DATA_API_KEY$6 = ".data-api";
2122        const CLASS_NAME_ACTIVE$3 = "active";
2123        const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
2124        const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`;
2125        class Button extends BaseComponent {
2126          // Getters
2127          static get NAME() {
2128            return NAME$e;
2129          }
2130          // Public
2131          toggle() {
2132            this._element.setAttribute("aria-pressed", this._element.classList.toggle(CLASS_NAME_ACTIVE$3));
2133          }
2134          // Static
2135          static jQueryInterface(config3) {
2136            return this.each(function() {
2137              const data = Button.getOrCreateInstance(this);
2138              if (config3 === "toggle") {
2139                data[config3]();
2140              }
2141            });
2142          }
2143        }
2144        EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, (event) => {
2145          event.preventDefault();
2146          const button = event.target.closest(SELECTOR_DATA_TOGGLE$5);
2147          const data = Button.getOrCreateInstance(button);
2148          data.toggle();
2149        });
2150        defineJQueryPlugin(Button);
2151        const NAME$d = "swipe";
2152        const EVENT_KEY$9 = ".bs.swipe";
2153        const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$9}`;
2154        const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$9}`;
2155        const EVENT_TOUCHEND = `touchend${EVENT_KEY$9}`;
2156        const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$9}`;
2157        const EVENT_POINTERUP = `pointerup${EVENT_KEY$9}`;
2158        const POINTER_TYPE_TOUCH = "touch";
2159        const POINTER_TYPE_PEN = "pen";
2160        const CLASS_NAME_POINTER_EVENT = "pointer-event";
2161        const SWIPE_THRESHOLD = 40;
2162        const Default$c = {
2163          endCallback: null,
2164          leftCallback: null,
2165          rightCallback: null
2166        };
2167        const DefaultType$c = {
2168          endCallback: "(function|null)",
2169          leftCallback: "(function|null)",
2170          rightCallback: "(function|null)"
2171        };
2172        class Swipe extends Config {
2173          constructor(element, config3) {
2174            super();
2175            this._element = element;
2176            if (!element || !Swipe.isSupported()) {
2177              return;
2178            }
2179            this._config = this._getConfig(config3);
2180            this._deltaX = 0;
2181            this._supportPointerEvents = Boolean(window.PointerEvent);
2182            this._initEvents();
2183          }
2184          // Getters
2185          static get Default() {
2186            return Default$c;
2187          }
2188          static get DefaultType() {
2189            return DefaultType$c;
2190          }
2191          static get NAME() {
2192            return NAME$d;
2193          }
2194          // Public
2195          dispose() {
2196            EventHandler.off(this._element, EVENT_KEY$9);
2197          }
2198          // Private
2199          _start(event) {
2200            if (!this._supportPointerEvents) {
2201              this._deltaX = event.touches[0].clientX;
2202              return;
2203            }
2204            if (this._eventIsPointerPenTouch(event)) {
2205              this._deltaX = event.clientX;
2206            }
2207          }
2208          _end(event) {
2209            if (this._eventIsPointerPenTouch(event)) {
2210              this._deltaX = event.clientX - this._deltaX;
2211            }
2212            this._handleSwipe();
2213            execute2(this._config.endCallback);
2214          }
2215          _move(event) {
2216            this._deltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this._deltaX;
2217          }
2218          _handleSwipe() {
2219            const absDeltaX = Math.abs(this._deltaX);
2220            if (absDeltaX <= SWIPE_THRESHOLD) {
2221              return;
2222            }
2223            const direction = absDeltaX / this._deltaX;
2224            this._deltaX = 0;
2225            if (!direction) {
2226              return;
2227            }
2228            execute2(direction > 0 ? this._config.rightCallback : this._config.leftCallback);
2229          }
2230          _initEvents() {
2231            if (this._supportPointerEvents) {
2232              EventHandler.on(this._element, EVENT_POINTERDOWN, (event) => this._start(event));
2233              EventHandler.on(this._element, EVENT_POINTERUP, (event) => this._end(event));
2234              this._element.classList.add(CLASS_NAME_POINTER_EVENT);
2235            } else {
2236              EventHandler.on(this._element, EVENT_TOUCHSTART, (event) => this._start(event));
2237              EventHandler.on(this._element, EVENT_TOUCHMOVE, (event) => this._move(event));
2238              EventHandler.on(this._element, EVENT_TOUCHEND, (event) => this._end(event));
2239            }
2240          }
2241          _eventIsPointerPenTouch(event) {
2242            return this._supportPointerEvents && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH);
2243          }
2244          // Static
2245          static isSupported() {
2246            return "ontouchstart" in document.documentElement || navigator.maxTouchPoints > 0;
2247          }
2248        }
2249        const NAME$c = "carousel";
2250        const DATA_KEY$8 = "bs.carousel";
2251        const EVENT_KEY$8 = `.${DATA_KEY$8}`;
2252        const DATA_API_KEY$5 = ".data-api";
2253        const ARROW_LEFT_KEY$1 = "ArrowLeft";
2254        const ARROW_RIGHT_KEY$1 = "ArrowRight";
2255        const TOUCHEVENT_COMPAT_WAIT = 500;
2256        const ORDER_NEXT = "next";
2257        const ORDER_PREV = "prev";
2258        const DIRECTION_LEFT = "left";
2259        const DIRECTION_RIGHT = "right";
2260        const EVENT_SLIDE = `slide${EVENT_KEY$8}`;
2261        const EVENT_SLID = `slid${EVENT_KEY$8}`;
2262        const EVENT_KEYDOWN$1 = `keydown${EVENT_KEY$8}`;
2263        const EVENT_MOUSEENTER$1 = `mouseenter${EVENT_KEY$8}`;
2264        const EVENT_MOUSELEAVE$1 = `mouseleave${EVENT_KEY$8}`;
2265        const EVENT_DRAG_START = `dragstart${EVENT_KEY$8}`;
2266        const EVENT_LOAD_DATA_API$3 = `load${EVENT_KEY$8}${DATA_API_KEY$5}`;
2267        const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`;
2268        const CLASS_NAME_CAROUSEL = "carousel";
2269        const CLASS_NAME_ACTIVE$2 = "active";
2270        const CLASS_NAME_SLIDE = "slide";
2271        const CLASS_NAME_END = "carousel-item-end";
2272        const CLASS_NAME_START = "carousel-item-start";
2273        const CLASS_NAME_NEXT = "carousel-item-next";
2274        const CLASS_NAME_PREV = "carousel-item-prev";
2275        const SELECTOR_ACTIVE = ".active";
2276        const SELECTOR_ITEM = ".carousel-item";
2277        const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_ITEM;
2278        const SELECTOR_ITEM_IMG = ".carousel-item img";
2279        const SELECTOR_INDICATORS = ".carousel-indicators";
2280        const SELECTOR_DATA_SLIDE = "[data-bs-slide], [data-bs-slide-to]";
2281        const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
2282        const KEY_TO_DIRECTION = {
2283          [ARROW_LEFT_KEY$1]: DIRECTION_RIGHT,
2284          [ARROW_RIGHT_KEY$1]: DIRECTION_LEFT
2285        };
2286        const Default$b = {
2287          interval: 5e3,
2288          keyboard: true,
2289          pause: "hover",
2290          ride: false,
2291          touch: true,
2292          wrap: true
2293        };
2294        const DefaultType$b = {
2295          interval: "(number|boolean)",
2296          // TODO:v6 remove boolean support
2297          keyboard: "boolean",
2298          pause: "(string|boolean)",
2299          ride: "(boolean|string)",
2300          touch: "boolean",
2301          wrap: "boolean"
2302        };
2303        class Carousel extends BaseComponent {
2304          constructor(element, config3) {
2305            super(element, config3);
2306            this._interval = null;
2307            this._activeElement = null;
2308            this._isSliding = false;
2309            this.touchTimeout = null;
2310            this._swipeHelper = null;
2311            this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
2312            this._addEventListeners();
2313            if (this._config.ride === CLASS_NAME_CAROUSEL) {
2314              this.cycle();
2315            }
2316          }
2317          // Getters
2318          static get Default() {
2319            return Default$b;
2320          }
2321          static get DefaultType() {
2322            return DefaultType$b;
2323          }
2324          static get NAME() {
2325            return NAME$c;
2326          }
2327          // Public
2328          next() {
2329            this._slide(ORDER_NEXT);
2330          }
2331          nextWhenVisible() {
2332            if (!document.hidden && isVisible(this._element)) {
2333              this.next();
2334            }
2335          }
2336          prev() {
2337            this._slide(ORDER_PREV);
2338          }
2339          pause() {
2340            if (this._isSliding) {
2341              triggerTransitionEnd(this._element);
2342            }
2343            this._clearInterval();
2344          }
2345          cycle() {
2346            this._clearInterval();
2347            this._updateInterval();
2348            this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);
2349          }
2350          _maybeEnableCycle() {
2351            if (!this._config.ride) {
2352              return;
2353            }
2354            if (this._isSliding) {
2355              EventHandler.one(this._element, EVENT_SLID, () => this.cycle());
2356              return;
2357            }
2358            this.cycle();
2359          }
2360          to(index) {
2361            const items = this._getItems();
2362            if (index > items.length - 1 || index < 0) {
2363              return;
2364            }
2365            if (this._isSliding) {
2366              EventHandler.one(this._element, EVENT_SLID, () => this.to(index));
2367              return;
2368            }
2369            const activeIndex = this._getItemIndex(this._getActive());
2370            if (activeIndex === index) {
2371              return;
2372            }
2373            const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
2374            this._slide(order, items[index]);
2375          }
2376          dispose() {
2377            if (this._swipeHelper) {
2378              this._swipeHelper.dispose();
2379            }
2380            super.dispose();
2381          }
2382          // Private
2383          _configAfterMerge(config3) {
2384            config3.defaultInterval = config3.interval;
2385            return config3;
2386          }
2387          _addEventListeners() {
2388            if (this._config.keyboard) {
2389              EventHandler.on(this._element, EVENT_KEYDOWN$1, (event) => this._keydown(event));
2390            }
2391            if (this._config.pause === "hover") {
2392              EventHandler.on(this._element, EVENT_MOUSEENTER$1, () => this.pause());
2393              EventHandler.on(this._element, EVENT_MOUSELEAVE$1, () => this._maybeEnableCycle());
2394            }
2395            if (this._config.touch && Swipe.isSupported()) {
2396              this._addTouchEventListeners();
2397            }
2398          }
2399          _addTouchEventListeners() {
2400            for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {
2401              EventHandler.on(img, EVENT_DRAG_START, (event) => event.preventDefault());
2402            }
2403            const endCallBack = () => {
2404              if (this._config.pause !== "hover") {
2405                return;
2406              }
2407              this.pause();
2408              if (this.touchTimeout) {
2409                clearTimeout(this.touchTimeout);
2410              }
2411              this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval);
2412            };
2413            const swipeConfig = {
2414              leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
2415              rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
2416              endCallback: endCallBack
2417            };
2418            this._swipeHelper = new Swipe(this._element, swipeConfig);
2419          }
2420          _keydown(event) {
2421            if (/input|textarea/i.test(event.target.tagName)) {
2422              return;
2423            }
2424            const direction = KEY_TO_DIRECTION[event.key];
2425            if (direction) {
2426              event.preventDefault();
2427              this._slide(this._directionToOrder(direction));
2428            }
2429          }
2430          _getItemIndex(element) {
2431            return this._getItems().indexOf(element);
2432          }
2433          _setActiveIndicatorElement(index) {
2434            if (!this._indicatorsElement) {
2435              return;
2436            }
2437            const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
2438            activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);
2439            activeIndicator.removeAttribute("aria-current");
2440            const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement);
2441            if (newActiveIndicator) {
2442              newActiveIndicator.classList.add(CLASS_NAME_ACTIVE$2);
2443              newActiveIndicator.setAttribute("aria-current", "true");
2444            }
2445          }
2446          _updateInterval() {
2447            const element = this._activeElement || this._getActive();
2448            if (!element) {
2449              return;
2450            }
2451            const elementInterval = Number.parseInt(element.getAttribute("data-bs-interval"), 10);
2452            this._config.interval = elementInterval || this._config.defaultInterval;
2453          }
2454          _slide(order, element = null) {
2455            if (this._isSliding) {
2456              return;
2457            }
2458            const activeElement = this._getActive();
2459            const isNext = order === ORDER_NEXT;
2460            const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);
2461            if (nextElement === activeElement) {
2462              return;
2463            }
2464            const nextElementIndex = this._getItemIndex(nextElement);
2465            const triggerEvent = (eventName) => {
2466              return EventHandler.trigger(this._element, eventName, {
2467                relatedTarget: nextElement,
2468                direction: this._orderToDirection(order),
2469                from: this._getItemIndex(activeElement),
2470                to: nextElementIndex
2471              });
2472            };
2473            const slideEvent = triggerEvent(EVENT_SLIDE);
2474            if (slideEvent.defaultPrevented) {
2475              return;
2476            }
2477            if (!activeElement || !nextElement) {
2478              return;
2479            }
2480            const isCycling = Boolean(this._interval);
2481            this.pause();
2482            this._isSliding = true;
2483            this._setActiveIndicatorElement(nextElementIndex);
2484            this._activeElement = nextElement;
2485            const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
2486            const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
2487            nextElement.classList.add(orderClassName);
2488            reflow(nextElement);
2489            activeElement.classList.add(directionalClassName);
2490            nextElement.classList.add(directionalClassName);
2491            const completeCallBack = () => {
2492              nextElement.classList.remove(directionalClassName, orderClassName);
2493              nextElement.classList.add(CLASS_NAME_ACTIVE$2);
2494              activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
2495              this._isSliding = false;
2496              triggerEvent(EVENT_SLID);
2497            };
2498            this._queueCallback(completeCallBack, activeElement, this._isAnimated());
2499            if (isCycling) {
2500              this.cycle();
2501            }
2502          }
2503          _isAnimated() {
2504            return this._element.classList.contains(CLASS_NAME_SLIDE);
2505          }
2506          _getActive() {
2507            return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
2508          }
2509          _getItems() {
2510            return SelectorEngine.find(SELECTOR_ITEM, this._element);
2511          }
2512          _clearInterval() {
2513            if (this._interval) {
2514              clearInterval(this._interval);
2515              this._interval = null;
2516            }
2517          }
2518          _directionToOrder(direction) {
2519            if (isRTL()) {
2520              return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
2521            }
2522            return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
2523          }
2524          _orderToDirection(order) {
2525            if (isRTL()) {
2526              return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
2527            }
2528            return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
2529          }
2530          // Static
2531          static jQueryInterface(config3) {
2532            return this.each(function() {
2533              const data = Carousel.getOrCreateInstance(this, config3);
2534              if (typeof config3 === "number") {
2535                data.to(config3);
2536                return;
2537              }
2538              if (typeof config3 === "string") {
2539                if (data[config3] === void 0 || config3.startsWith("_") || config3 === "constructor") {
2540                  throw new TypeError(`No method named "${config3}"`);
2541                }
2542                data[config3]();
2543              }
2544            });
2545          }
2546        }
2547        EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, function(event) {
2548          const target = SelectorEngine.getElementFromSelector(this);
2549          if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
2550            return;
2551          }
2552          event.preventDefault();
2553          const carousel = Carousel.getOrCreateInstance(target);
2554          const slideIndex = this.getAttribute("data-bs-slide-to");
2555          if (slideIndex) {
2556            carousel.to(slideIndex);
2557            carousel._maybeEnableCycle();
2558            return;
2559          }
2560          if (Manipulator.getDataAttribute(this, "slide") === "next") {
2561            carousel.next();
2562            carousel._maybeEnableCycle();
2563            return;
2564          }
2565          carousel.prev();
2566          carousel._maybeEnableCycle();
2567        });
2568        EventHandler.on(window, EVENT_LOAD_DATA_API$3, () => {
2569          const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
2570          for (const carousel of carousels) {
2571            Carousel.getOrCreateInstance(carousel);
2572          }
2573        });
2574        defineJQueryPlugin(Carousel);
2575        const NAME$b = "collapse";
2576        const DATA_KEY$7 = "bs.collapse";
2577        const EVENT_KEY$7 = `.${DATA_KEY$7}`;
2578        const DATA_API_KEY$4 = ".data-api";
2579        const EVENT_SHOW$6 = `show${EVENT_KEY$7}`;
2580        const EVENT_SHOWN$6 = `shown${EVENT_KEY$7}`;
2581        const EVENT_HIDE$6 = `hide${EVENT_KEY$7}`;
2582        const EVENT_HIDDEN$6 = `hidden${EVENT_KEY$7}`;
2583        const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`;
2584        const CLASS_NAME_SHOW$7 = "show";
2585        const CLASS_NAME_COLLAPSE = "collapse";
2586        const CLASS_NAME_COLLAPSING = "collapsing";
2587        const CLASS_NAME_COLLAPSED = "collapsed";
2588        const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`;
2589        const CLASS_NAME_HORIZONTAL = "collapse-horizontal";
2590        const WIDTH = "width";
2591        const HEIGHT = "height";
2592        const SELECTOR_ACTIVES = ".collapse.show, .collapse.collapsing";
2593        const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]';
2594        const Default$a = {
2595          parent: null,
2596          toggle: true
2597        };
2598        const DefaultType$a = {
2599          parent: "(null|element)",
2600          toggle: "boolean"
2601        };
2602        class Collapse extends BaseComponent {
2603          constructor(element, config3) {
2604            super(element, config3);
2605            this._isTransitioning = false;
2606            this._triggerArray = [];
2607            const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);
2608            for (const elem of toggleList) {
2609              const selector3 = SelectorEngine.getSelectorFromElement(elem);
2610              const filterElement = SelectorEngine.find(selector3).filter((foundElement) => foundElement === this._element);
2611              if (selector3 !== null && filterElement.length) {
2612                this._triggerArray.push(elem);
2613              }
2614            }
2615            this._initializeChildren();
2616            if (!this._config.parent) {
2617              this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());
2618            }
2619            if (this._config.toggle) {
2620              this.toggle();
2621            }
2622          }
2623          // Getters
2624          static get Default() {
2625            return Default$a;
2626          }
2627          static get DefaultType() {
2628            return DefaultType$a;
2629          }
2630          static get NAME() {
2631            return NAME$b;
2632          }
2633          // Public
2634          toggle() {
2635            if (this._isShown()) {
2636              this.hide();
2637            } else {
2638              this.show();
2639            }
2640          }
2641          show() {
2642            if (this._isTransitioning || this._isShown()) {
2643              return;
2644            }
2645            let activeChildren = [];
2646            if (this._config.parent) {
2647              activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES).filter((element) => element !== this._element).map((element) => Collapse.getOrCreateInstance(element, {
2648                toggle: false
2649              }));
2650            }
2651            if (activeChildren.length && activeChildren[0]._isTransitioning) {
2652              return;
2653            }
2654            const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$6);
2655            if (startEvent.defaultPrevented) {
2656              return;
2657            }
2658            for (const activeInstance of activeChildren) {
2659              activeInstance.hide();
2660            }
2661            const dimension = this._getDimension();
2662            this._element.classList.remove(CLASS_NAME_COLLAPSE);
2663            this._element.classList.add(CLASS_NAME_COLLAPSING);
2664            this._element.style[dimension] = 0;
2665            this._addAriaAndCollapsedClass(this._triggerArray, true);
2666            this._isTransitioning = true;
2667            const complete = () => {
2668              this._isTransitioning = false;
2669              this._element.classList.remove(CLASS_NAME_COLLAPSING);
2670              this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
2671              this._element.style[dimension] = "";
2672              EventHandler.trigger(this._element, EVENT_SHOWN$6);
2673            };
2674            const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
2675            const scrollSize = `scroll${capitalizedDimension}`;
2676            this._queueCallback(complete, this._element, true);
2677            this._element.style[dimension] = `${this._element[scrollSize]}px`;
2678          }
2679          hide() {
2680            if (this._isTransitioning || !this._isShown()) {
2681              return;
2682            }
2683            const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6);
2684            if (startEvent.defaultPrevented) {
2685              return;
2686            }
2687            const dimension = this._getDimension();
2688            this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;
2689            reflow(this._element);
2690            this._element.classList.add(CLASS_NAME_COLLAPSING);
2691            this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
2692            for (const trigger of this._triggerArray) {
2693              const element = SelectorEngine.getElementFromSelector(trigger);
2694              if (element && !this._isShown(element)) {
2695                this._addAriaAndCollapsedClass([trigger], false);
2696              }
2697            }
2698            this._isTransitioning = true;
2699            const complete = () => {
2700              this._isTransitioning = false;
2701              this._element.classList.remove(CLASS_NAME_COLLAPSING);
2702              this._element.classList.add(CLASS_NAME_COLLAPSE);
2703              EventHandler.trigger(this._element, EVENT_HIDDEN$6);
2704            };
2705            this._element.style[dimension] = "";
2706            this._queueCallback(complete, this._element, true);
2707          }
2708          // Private
2709          _isShown(element = this._element) {
2710            return element.classList.contains(CLASS_NAME_SHOW$7);
2711          }
2712          _configAfterMerge(config3) {
2713            config3.toggle = Boolean(config3.toggle);
2714            config3.parent = getElement(config3.parent);
2715            return config3;
2716          }
2717          _getDimension() {
2718            return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;
2719          }
2720          _initializeChildren() {
2721            if (!this._config.parent) {
2722              return;
2723            }
2724            const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE$4);
2725            for (const element of children) {
2726              const selected = SelectorEngine.getElementFromSelector(element);
2727              if (selected) {
2728                this._addAriaAndCollapsedClass([element], this._isShown(selected));
2729              }
2730            }
2731          }
2732          _getFirstLevelChildren(selector3) {
2733            const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
2734            return SelectorEngine.find(selector3, this._config.parent).filter((element) => !children.includes(element));
2735          }
2736          _addAriaAndCollapsedClass(triggerArray, isOpen) {
2737            if (!triggerArray.length) {
2738              return;
2739            }
2740            for (const element of triggerArray) {
2741              element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen);
2742              element.setAttribute("aria-expanded", isOpen);
2743            }
2744          }
2745          // Static
2746          static jQueryInterface(config3) {
2747            const _config2 = {};
2748            if (typeof config3 === "string" && /show|hide/.test(config3)) {
2749              _config2.toggle = false;
2750            }
2751            return this.each(function() {
2752              const data = Collapse.getOrCreateInstance(this, _config2);
2753              if (typeof config3 === "string") {
2754                if (typeof data[config3] === "undefined") {
2755                  throw new TypeError(`No method named "${config3}"`);
2756                }
2757                data[config3]();
2758              }
2759            });
2760          }
2761        }
2762        EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function(event) {
2763          if (event.target.tagName === "A" || event.delegateTarget && event.delegateTarget.tagName === "A") {
2764            event.preventDefault();
2765          }
2766          for (const element of SelectorEngine.getMultipleElementsFromSelector(this)) {
2767            Collapse.getOrCreateInstance(element, {
2768              toggle: false
2769            }).toggle();
2770          }
2771        });
2772        defineJQueryPlugin(Collapse);
2773        const NAME$a = "dropdown";
2774        const DATA_KEY$6 = "bs.dropdown";
2775        const EVENT_KEY$6 = `.${DATA_KEY$6}`;
2776        const DATA_API_KEY$3 = ".data-api";
2777        const ESCAPE_KEY$2 = "Escape";
2778        const TAB_KEY$1 = "Tab";
2779        const ARROW_UP_KEY$1 = "ArrowUp";
2780        const ARROW_DOWN_KEY$1 = "ArrowDown";
2781        const RIGHT_MOUSE_BUTTON = 2;
2782        const EVENT_HIDE$5 = `hide${EVENT_KEY$6}`;
2783        const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$6}`;
2784        const EVENT_SHOW$5 = `show${EVENT_KEY$6}`;
2785        const EVENT_SHOWN$5 = `shown${EVENT_KEY$6}`;
2786        const EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`;
2787        const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$6}${DATA_API_KEY$3}`;
2788        const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$6}${DATA_API_KEY$3}`;
2789        const CLASS_NAME_SHOW$6 = "show";
2790        const CLASS_NAME_DROPUP = "dropup";
2791        const CLASS_NAME_DROPEND = "dropend";
2792        const CLASS_NAME_DROPSTART = "dropstart";
2793        const CLASS_NAME_DROPUP_CENTER = "dropup-center";
2794        const CLASS_NAME_DROPDOWN_CENTER = "dropdown-center";
2795        const SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)';
2796        const SELECTOR_DATA_TOGGLE_SHOWN = `${SELECTOR_DATA_TOGGLE$3}.${CLASS_NAME_SHOW$6}`;
2797        const SELECTOR_MENU = ".dropdown-menu";
2798        const SELECTOR_NAVBAR = ".navbar";
2799        const SELECTOR_NAVBAR_NAV = ".navbar-nav";
2800        const SELECTOR_VISIBLE_ITEMS = ".dropdown-menu .dropdown-item:not(.disabled):not(:disabled)";
2801        const PLACEMENT_TOP = isRTL() ? "top-end" : "top-start";
2802        const PLACEMENT_TOPEND = isRTL() ? "top-start" : "top-end";
2803        const PLACEMENT_BOTTOM = isRTL() ? "bottom-end" : "bottom-start";
2804        const PLACEMENT_BOTTOMEND = isRTL() ? "bottom-start" : "bottom-end";
2805        const PLACEMENT_RIGHT = isRTL() ? "left-start" : "right-start";
2806        const PLACEMENT_LEFT = isRTL() ? "right-start" : "left-start";
2807        const PLACEMENT_TOPCENTER = "top";
2808        const PLACEMENT_BOTTOMCENTER = "bottom";
2809        const Default$9 = {
2810          autoClose: true,
2811          boundary: "clippingParents",
2812          display: "dynamic",
2813          offset: [0, 2],
2814          popperConfig: null,
2815          reference: "toggle"
2816        };
2817        const DefaultType$9 = {
2818          autoClose: "(boolean|string)",
2819          boundary: "(string|element)",
2820          display: "string",
2821          offset: "(array|string|function)",
2822          popperConfig: "(null|object|function)",
2823          reference: "(string|element|object)"
2824        };
2825        class Dropdown extends BaseComponent {
2826          constructor(element, config3) {
2827            super(element, config3);
2828            this._popper = null;
2829            this._parent = this._element.parentNode;
2830            this._menu = SelectorEngine.next(this._element, SELECTOR_MENU)[0] || SelectorEngine.prev(this._element, SELECTOR_MENU)[0] || SelectorEngine.findOne(SELECTOR_MENU, this._parent);
2831            this._inNavbar = this._detectNavbar();
2832          }
2833          // Getters
2834          static get Default() {
2835            return Default$9;
2836          }
2837          static get DefaultType() {
2838            return DefaultType$9;
2839          }
2840          static get NAME() {
2841            return NAME$a;
2842          }
2843          // Public
2844          toggle() {
2845            return this._isShown() ? this.hide() : this.show();
2846          }
2847          show() {
2848            if (isDisabled(this._element) || this._isShown()) {
2849              return;
2850            }
2851            const relatedTarget = {
2852              relatedTarget: this._element
2853            };
2854            const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$5, relatedTarget);
2855            if (showEvent.defaultPrevented) {
2856              return;
2857            }
2858            this._createPopper();
2859            if ("ontouchstart" in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) {
2860              for (const element of [].concat(...document.body.children)) {
2861                EventHandler.on(element, "mouseover", noop);
2862              }
2863            }
2864            this._element.focus();
2865            this._element.setAttribute("aria-expanded", true);
2866            this._menu.classList.add(CLASS_NAME_SHOW$6);
2867            this._element.classList.add(CLASS_NAME_SHOW$6);
2868            EventHandler.trigger(this._element, EVENT_SHOWN$5, relatedTarget);
2869          }
2870          hide() {
2871            if (isDisabled(this._element) || !this._isShown()) {
2872              return;
2873            }
2874            const relatedTarget = {
2875              relatedTarget: this._element
2876            };
2877            this._completeHide(relatedTarget);
2878          }
2879          dispose() {
2880            if (this._popper) {
2881              this._popper.destroy();
2882            }
2883            super.dispose();
2884          }
2885          update() {
2886            this._inNavbar = this._detectNavbar();
2887            if (this._popper) {
2888              this._popper.update();
2889            }
2890          }
2891          // Private
2892          _completeHide(relatedTarget) {
2893            const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$5, relatedTarget);
2894            if (hideEvent.defaultPrevented) {
2895              return;
2896            }
2897            if ("ontouchstart" in document.documentElement) {
2898              for (const element of [].concat(...document.body.children)) {
2899                EventHandler.off(element, "mouseover", noop);
2900              }
2901            }
2902            if (this._popper) {
2903              this._popper.destroy();
2904            }
2905            this._menu.classList.remove(CLASS_NAME_SHOW$6);
2906            this._element.classList.remove(CLASS_NAME_SHOW$6);
2907            this._element.setAttribute("aria-expanded", "false");
2908            Manipulator.removeDataAttribute(this._menu, "popper");
2909            EventHandler.trigger(this._element, EVENT_HIDDEN$5, relatedTarget);
2910          }
2911          _getConfig(config3) {
2912            config3 = super._getConfig(config3);
2913            if (typeof config3.reference === "object" && !isElement(config3.reference) && typeof config3.reference.getBoundingClientRect !== "function") {
2914              throw new TypeError(`${NAME$a.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);
2915            }
2916            return config3;
2917          }
2918          _createPopper() {
2919            if (typeof Popper__namespace === "undefined") {
2920              throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org/docs/v2/)");
2921            }
2922            let referenceElement = this._element;
2923            if (this._config.reference === "parent") {
2924              referenceElement = this._parent;
2925            } else if (isElement(this._config.reference)) {
2926              referenceElement = getElement(this._config.reference);
2927            } else if (typeof this._config.reference === "object") {
2928              referenceElement = this._config.reference;
2929            }
2930            const popperConfig = this._getPopperConfig();
2931            this._popper = Popper__namespace.createPopper(referenceElement, this._menu, popperConfig);
2932          }
2933          _isShown() {
2934            return this._menu.classList.contains(CLASS_NAME_SHOW$6);
2935          }
2936          _getPlacement() {
2937            const parentDropdown = this._parent;
2938            if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
2939              return PLACEMENT_RIGHT;
2940            }
2941            if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {
2942              return PLACEMENT_LEFT;
2943            }
2944            if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) {
2945              return PLACEMENT_TOPCENTER;
2946            }
2947            if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENTER)) {
2948              return PLACEMENT_BOTTOMCENTER;
2949            }
2950            const isEnd = getComputedStyle(this._menu).getPropertyValue("--bs-position").trim() === "end";
2951            if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {
2952              return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;
2953            }
2954            return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;
2955          }
2956          _detectNavbar() {
2957            return this._element.closest(SELECTOR_NAVBAR) !== null;
2958          }
2959          _getOffset() {
2960            const {
2961              offset
2962            } = this._config;
2963            if (typeof offset === "string") {
2964              return offset.split(",").map((value) => Number.parseInt(value, 10));
2965            }
2966            if (typeof offset === "function") {
2967              return (popperData) => offset(popperData, this._element);
2968            }
2969            return offset;
2970          }
2971          _getPopperConfig() {
2972            const defaultBsPopperConfig = {
2973              placement: this._getPlacement(),
2974              modifiers: [{
2975                name: "preventOverflow",
2976                options: {
2977                  boundary: this._config.boundary
2978                }
2979              }, {
2980                name: "offset",
2981                options: {
2982                  offset: this._getOffset()
2983                }
2984              }]
2985            };
2986            if (this._inNavbar || this._config.display === "static") {
2987              Manipulator.setDataAttribute(this._menu, "popper", "static");
2988              defaultBsPopperConfig.modifiers = [{
2989                name: "applyStyles",
2990                enabled: false
2991              }];
2992            }
2993            return {
2994              ...defaultBsPopperConfig,
2995              ...execute2(this._config.popperConfig, [void 0, defaultBsPopperConfig])
2996            };
2997          }
2998          _selectMenuItem({
2999            key,
3000            target
3001          }) {
3002            const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter((element) => isVisible(element));
3003            if (!items.length) {
3004              return;
3005            }
3006            getNextActiveElement(items, target, key === ARROW_DOWN_KEY$1, !items.includes(target)).focus();
3007          }
3008          // Static
3009          static jQueryInterface(config3) {
3010            return this.each(function() {
3011              const data = Dropdown.getOrCreateInstance(this, config3);
3012              if (typeof config3 !== "string") {
3013                return;
3014              }
3015              if (typeof data[config3] === "undefined") {
3016                throw new TypeError(`No method named "${config3}"`);
3017              }
3018              data[config3]();
3019            });
3020          }
3021          static clearMenus(event) {
3022            if (event.button === RIGHT_MOUSE_BUTTON || event.type === "keyup" && event.key !== TAB_KEY$1) {
3023              return;
3024            }
3025            const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN);
3026            for (const toggle of openToggles) {
3027              const context3 = Dropdown.getInstance(toggle);
3028              if (!context3 || context3._config.autoClose === false) {
3029                continue;
3030              }
3031              const composedPath = event.composedPath();
3032              const isMenuTarget = composedPath.includes(context3._menu);
3033              if (composedPath.includes(context3._element) || context3._config.autoClose === "inside" && !isMenuTarget || context3._config.autoClose === "outside" && isMenuTarget) {
3034                continue;
3035              }
3036              if (context3._menu.contains(event.target) && (event.type === "keyup" && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) {
3037                continue;
3038              }
3039              const relatedTarget = {
3040                relatedTarget: context3._element
3041              };
3042              if (event.type === "click") {
3043                relatedTarget.clickEvent = event;
3044              }
3045              context3._completeHide(relatedTarget);
3046            }
3047          }
3048          static dataApiKeydownHandler(event) {
3049            const isInput2 = /input|textarea/i.test(event.target.tagName);
3050            const isEscapeEvent = event.key === ESCAPE_KEY$2;
3051            const isUpOrDownEvent = [ARROW_UP_KEY$1, ARROW_DOWN_KEY$1].includes(event.key);
3052            if (!isUpOrDownEvent && !isEscapeEvent) {
3053              return;
3054            }
3055            if (isInput2 && !isEscapeEvent) {
3056              return;
3057            }
3058            event.preventDefault();
3059            const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.next(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.findOne(SELECTOR_DATA_TOGGLE$3, event.delegateTarget.parentNode);
3060            const instance = Dropdown.getOrCreateInstance(getToggleButton);
3061            if (isUpOrDownEvent) {
3062              event.stopPropagation();
3063              instance.show();
3064              instance._selectMenuItem(event);
3065              return;
3066            }
3067            if (instance._isShown()) {
3068              event.stopPropagation();
3069              instance.hide();
3070              getToggleButton.focus();
3071            }
3072          }
3073        }
3074        EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler);
3075        EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler);
3076        EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus);
3077        EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);
3078        EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function(event) {
3079          event.preventDefault();
3080          Dropdown.getOrCreateInstance(this).toggle();
3081        });
3082        defineJQueryPlugin(Dropdown);
3083        const NAME$9 = "backdrop";
3084        const CLASS_NAME_FADE$4 = "fade";
3085        const CLASS_NAME_SHOW$5 = "show";
3086        const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$9}`;
3087        const Default$8 = {
3088          className: "modal-backdrop",
3089          clickCallback: null,
3090          isAnimated: false,
3091          isVisible: true,
3092          // if false, we use the backdrop helper without adding any element to the dom
3093          rootElement: "body"
3094          // give the choice to place backdrop under different elements
3095        };
3096        const DefaultType$8 = {
3097          className: "string",
3098          clickCallback: "(function|null)",
3099          isAnimated: "boolean",
3100          isVisible: "boolean",
3101          rootElement: "(element|string)"
3102        };
3103        class Backdrop extends Config {
3104          constructor(config3) {
3105            super();
3106            this._config = this._getConfig(config3);
3107            this._isAppended = false;
3108            this._element = null;
3109          }
3110          // Getters
3111          static get Default() {
3112            return Default$8;
3113          }
3114          static get DefaultType() {
3115            return DefaultType$8;
3116          }
3117          static get NAME() {
3118            return NAME$9;
3119          }
3120          // Public
3121          show(callback) {
3122            if (!this._config.isVisible) {
3123              execute2(callback);
3124              return;
3125            }
3126            this._append();
3127            const element = this._getElement();
3128            if (this._config.isAnimated) {
3129              reflow(element);
3130            }
3131            element.classList.add(CLASS_NAME_SHOW$5);
3132            this._emulateAnimation(() => {
3133              execute2(callback);
3134            });
3135          }
3136          hide(callback) {
3137            if (!this._config.isVisible) {
3138              execute2(callback);
3139              return;
3140            }
3141            this._getElement().classList.remove(CLASS_NAME_SHOW$5);
3142            this._emulateAnimation(() => {
3143              this.dispose();
3144              execute2(callback);
3145            });
3146          }
3147          dispose() {
3148            if (!this._isAppended) {
3149              return;
3150            }
3151            EventHandler.off(this._element, EVENT_MOUSEDOWN);
3152            this._element.remove();
3153            this._isAppended = false;
3154          }
3155          // Private
3156          _getElement() {
3157            if (!this._element) {
3158              const backdrop = document.createElement("div");
3159              backdrop.className = this._config.className;
3160              if (this._config.isAnimated) {
3161                backdrop.classList.add(CLASS_NAME_FADE$4);
3162              }
3163              this._element = backdrop;
3164            }
3165            return this._element;
3166          }
3167          _configAfterMerge(config3) {
3168            config3.rootElement = getElement(config3.rootElement);
3169            return config3;
3170          }
3171          _append() {
3172            if (this._isAppended) {
3173              return;
3174            }
3175            const element = this._getElement();
3176            this._config.rootElement.append(element);
3177            EventHandler.on(element, EVENT_MOUSEDOWN, () => {
3178              execute2(this._config.clickCallback);
3179            });
3180            this._isAppended = true;
3181          }
3182          _emulateAnimation(callback) {
3183            executeAfterTransition(callback, this._getElement(), this._config.isAnimated);
3184          }
3185        }
3186        const NAME$8 = "focustrap";
3187        const DATA_KEY$5 = "bs.focustrap";
3188        const EVENT_KEY$5 = `.${DATA_KEY$5}`;
3189        const EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$5}`;
3190        const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$5}`;
3191        const TAB_KEY = "Tab";
3192        const TAB_NAV_FORWARD = "forward";
3193        const TAB_NAV_BACKWARD = "backward";
3194        const Default$7 = {
3195          autofocus: true,
3196          trapElement: null
3197          // The element to trap focus inside of
3198        };
3199        const DefaultType$7 = {
3200          autofocus: "boolean",
3201          trapElement: "element"
3202        };
3203        class FocusTrap extends Config {
3204          constructor(config3) {
3205            super();
3206            this._config = this._getConfig(config3);
3207            this._isActive = false;
3208            this._lastTabNavDirection = null;
3209          }
3210          // Getters
3211          static get Default() {
3212            return Default$7;
3213          }
3214          static get DefaultType() {
3215            return DefaultType$7;
3216          }
3217          static get NAME() {
3218            return NAME$8;
3219          }
3220          // Public
3221          activate() {
3222            if (this._isActive) {
3223              return;
3224            }
3225            if (this._config.autofocus) {
3226              this._config.trapElement.focus();
3227            }
3228            EventHandler.off(document, EVENT_KEY$5);
3229            EventHandler.on(document, EVENT_FOCUSIN$2, (event) => this._handleFocusin(event));
3230            EventHandler.on(document, EVENT_KEYDOWN_TAB, (event) => this._handleKeydown(event));
3231            this._isActive = true;
3232          }
3233          deactivate() {
3234            if (!this._isActive) {
3235              return;
3236            }
3237            this._isActive = false;
3238            EventHandler.off(document, EVENT_KEY$5);
3239          }
3240          // Private
3241          _handleFocusin(event) {
3242            const {
3243              trapElement
3244            } = this._config;
3245            if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) {
3246              return;
3247            }
3248            const elements = SelectorEngine.focusableChildren(trapElement);
3249            if (elements.length === 0) {
3250              trapElement.focus();
3251            } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {
3252              elements[elements.length - 1].focus();
3253            } else {
3254              elements[0].focus();
3255            }
3256          }
3257          _handleKeydown(event) {
3258            if (event.key !== TAB_KEY) {
3259              return;
3260            }
3261            this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD;
3262          }
3263        }
3264        const SELECTOR_FIXED_CONTENT = ".fixed-top, .fixed-bottom, .is-fixed, .sticky-top";
3265        const SELECTOR_STICKY_CONTENT = ".sticky-top";
3266        const PROPERTY_PADDING = "padding-right";
3267        const PROPERTY_MARGIN = "margin-right";
3268        class ScrollBarHelper {
3269          constructor() {
3270            this._element = document.body;
3271          }
3272          // Public
3273          getWidth() {
3274            const documentWidth = document.documentElement.clientWidth;
3275            return Math.abs(window.innerWidth - documentWidth);
3276          }
3277          hide() {
3278            const width = this.getWidth();
3279            this._disableOverFlow();
3280            this._setElementAttributes(this._element, PROPERTY_PADDING, (calculatedValue) => calculatedValue + width);
3281            this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, (calculatedValue) => calculatedValue + width);
3282            this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, (calculatedValue) => calculatedValue - width);
3283          }
3284          reset() {
3285            this._resetElementAttributes(this._element, "overflow");
3286            this._resetElementAttributes(this._element, PROPERTY_PADDING);
3287            this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING);
3288            this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN);
3289          }
3290          isOverflowing() {
3291            return this.getWidth() > 0;
3292          }
3293          // Private
3294          _disableOverFlow() {
3295            this._saveInitialAttribute(this._element, "overflow");
3296            this._element.style.overflow = "hidden";
3297          }
3298          _setElementAttributes(selector3, styleProperty, callback) {
3299            const scrollbarWidth = this.getWidth();
3300            const manipulationCallBack = (element) => {
3301              if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
3302                return;
3303              }
3304              this._saveInitialAttribute(element, styleProperty);
3305              const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty);
3306              element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`);
3307            };
3308            this._applyManipulationCallback(selector3, manipulationCallBack);
3309          }
3310          _saveInitialAttribute(element, styleProperty) {
3311            const actualValue = element.style.getPropertyValue(styleProperty);
3312            if (actualValue) {
3313              Manipulator.setDataAttribute(element, styleProperty, actualValue);
3314            }
3315          }
3316          _resetElementAttributes(selector3, styleProperty) {
3317            const manipulationCallBack = (element) => {
3318              const value = Manipulator.getDataAttribute(element, styleProperty);
3319              if (value === null) {
3320                element.style.removeProperty(styleProperty);
3321                return;
3322              }
3323              Manipulator.removeDataAttribute(element, styleProperty);
3324              element.style.setProperty(styleProperty, value);
3325            };
3326            this._applyManipulationCallback(selector3, manipulationCallBack);
3327          }
3328          _applyManipulationCallback(selector3, callBack) {
3329            if (isElement(selector3)) {
3330              callBack(selector3);
3331              return;
3332            }
3333            for (const sel of SelectorEngine.find(selector3, this._element)) {
3334              callBack(sel);
3335            }
3336          }
3337        }
3338        const NAME$7 = "modal";
3339        const DATA_KEY$4 = "bs.modal";
3340        const EVENT_KEY$4 = `.${DATA_KEY$4}`;
3341        const DATA_API_KEY$2 = ".data-api";
3342        const ESCAPE_KEY$1 = "Escape";
3343        const EVENT_HIDE$4 = `hide${EVENT_KEY$4}`;
3344        const EVENT_HIDE_PREVENTED$1 = `hidePrevented${EVENT_KEY$4}`;
3345        const EVENT_HIDDEN$4 = `hidden${EVENT_KEY$4}`;
3346        const EVENT_SHOW$4 = `show${EVENT_KEY$4}`;
3347        const EVENT_SHOWN$4 = `shown${EVENT_KEY$4}`;
3348        const EVENT_RESIZE$1 = `resize${EVENT_KEY$4}`;
3349        const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY$4}`;
3350        const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$4}`;
3351        const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$4}`;
3352        const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$4}${DATA_API_KEY$2}`;
3353        const CLASS_NAME_OPEN = "modal-open";
3354        const CLASS_NAME_FADE$3 = "fade";
3355        const CLASS_NAME_SHOW$4 = "show";
3356        const CLASS_NAME_STATIC = "modal-static";
3357        const OPEN_SELECTOR$1 = ".modal.show";
3358        const SELECTOR_DIALOG = ".modal-dialog";
3359        const SELECTOR_MODAL_BODY = ".modal-body";
3360        const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]';
3361        const Default$6 = {
3362          backdrop: true,
3363          focus: true,
3364          keyboard: true
3365        };
3366        const DefaultType$6 = {
3367          backdrop: "(boolean|string)",
3368          focus: "boolean",
3369          keyboard: "boolean"
3370        };
3371        class Modal extends BaseComponent {
3372          constructor(element, config3) {
3373            super(element, config3);
3374            this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element);
3375            this._backdrop = this._initializeBackDrop();
3376            this._focustrap = this._initializeFocusTrap();
3377            this._isShown = false;
3378            this._isTransitioning = false;
3379            this._scrollBar = new ScrollBarHelper();
3380            this._addEventListeners();
3381          }
3382          // Getters
3383          static get Default() {
3384            return Default$6;
3385          }
3386          static get DefaultType() {
3387            return DefaultType$6;
3388          }
3389          static get NAME() {
3390            return NAME$7;
3391          }
3392          // Public
3393          toggle(relatedTarget) {
3394            return this._isShown ? this.hide() : this.show(relatedTarget);
3395          }
3396          show(relatedTarget) {
3397            if (this._isShown || this._isTransitioning) {
3398              return;
3399            }
3400            const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, {
3401              relatedTarget
3402            });
3403            if (showEvent.defaultPrevented) {
3404              return;
3405            }
3406            this._isShown = true;
3407            this._isTransitioning = true;
3408            this._scrollBar.hide();
3409            document.body.classList.add(CLASS_NAME_OPEN);
3410            this._adjustDialog();
3411            this._backdrop.show(() => this._showElement(relatedTarget));
3412          }
3413          hide() {
3414            if (!this._isShown || this._isTransitioning) {
3415              return;
3416            }
3417            const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4);
3418            if (hideEvent.defaultPrevented) {
3419              return;
3420            }
3421            this._isShown = false;
3422            this._isTransitioning = true;
3423            this._focustrap.deactivate();
3424            this._element.classList.remove(CLASS_NAME_SHOW$4);
3425            this._queueCallback(() => this._hideModal(), this._element, this._isAnimated());
3426          }
3427          dispose() {
3428            EventHandler.off(window, EVENT_KEY$4);
3429            EventHandler.off(this._dialog, EVENT_KEY$4);
3430            this._backdrop.dispose();
3431            this._focustrap.deactivate();
3432            super.dispose();
3433          }
3434          handleUpdate() {
3435            this._adjustDialog();
3436          }
3437          // Private
3438          _initializeBackDrop() {
3439            return new Backdrop({
3440              isVisible: Boolean(this._config.backdrop),
3441              // 'static' option will be translated to true, and booleans will keep their value,
3442              isAnimated: this._isAnimated()
3443            });
3444          }
3445          _initializeFocusTrap() {
3446            return new FocusTrap({
3447              trapElement: this._element
3448            });
3449          }
3450          _showElement(relatedTarget) {
3451            if (!document.body.contains(this._element)) {
3452              document.body.append(this._element);
3453            }
3454            this._element.style.display = "block";
3455            this._element.removeAttribute("aria-hidden");
3456            this._element.setAttribute("aria-modal", true);
3457            this._element.setAttribute("role", "dialog");
3458            this._element.scrollTop = 0;
3459            const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);
3460            if (modalBody) {
3461              modalBody.scrollTop = 0;
3462            }
3463            reflow(this._element);
3464            this._element.classList.add(CLASS_NAME_SHOW$4);
3465            const transitionComplete = () => {
3466              if (this._config.focus) {
3467                this._focustrap.activate();
3468              }
3469              this._isTransitioning = false;
3470              EventHandler.trigger(this._element, EVENT_SHOWN$4, {
3471                relatedTarget
3472              });
3473            };
3474            this._queueCallback(transitionComplete, this._dialog, this._isAnimated());
3475          }
3476          _addEventListeners() {
3477            EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, (event) => {
3478              if (event.key !== ESCAPE_KEY$1) {
3479                return;
3480              }
3481              if (this._config.keyboard) {
3482                this.hide();
3483                return;
3484              }
3485              this._triggerBackdropTransition();
3486            });
3487            EventHandler.on(window, EVENT_RESIZE$1, () => {
3488              if (this._isShown && !this._isTransitioning) {
3489                this._adjustDialog();
3490              }
3491            });
3492            EventHandler.on(this._element, EVENT_MOUSEDOWN_DISMISS, (event) => {
3493              EventHandler.one(this._element, EVENT_CLICK_DISMISS, (event2) => {
3494                if (this._element !== event.target || this._element !== event2.target) {
3495                  return;
3496                }
3497                if (this._config.backdrop === "static") {
3498                  this._triggerBackdropTransition();
3499                  return;
3500                }
3501                if (this._config.backdrop) {
3502                  this.hide();
3503                }
3504              });
3505            });
3506          }
3507          _hideModal() {
3508            this._element.style.display = "none";
3509            this._element.setAttribute("aria-hidden", true);
3510            this._element.removeAttribute("aria-modal");
3511            this._element.removeAttribute("role");
3512            this._isTransitioning = false;
3513            this._backdrop.hide(() => {
3514              document.body.classList.remove(CLASS_NAME_OPEN);
3515              this._resetAdjustments();
3516              this._scrollBar.reset();
3517              EventHandler.trigger(this._element, EVENT_HIDDEN$4);
3518            });
3519          }
3520          _isAnimated() {
3521            return this._element.classList.contains(CLASS_NAME_FADE$3);
3522          }
3523          _triggerBackdropTransition() {
3524            const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED$1);
3525            if (hideEvent.defaultPrevented) {
3526              return;
3527            }
3528            const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
3529            const initialOverflowY = this._element.style.overflowY;
3530            if (initialOverflowY === "hidden" || this._element.classList.contains(CLASS_NAME_STATIC)) {
3531              return;
3532            }
3533            if (!isModalOverflowing) {
3534              this._element.style.overflowY = "hidden";
3535            }
3536            this._element.classList.add(CLASS_NAME_STATIC);
3537            this._queueCallback(() => {
3538              this._element.classList.remove(CLASS_NAME_STATIC);
3539              this._queueCallback(() => {
3540                this._element.style.overflowY = initialOverflowY;
3541              }, this._dialog);
3542            }, this._dialog);
3543            this._element.focus();
3544          }
3545          /**
3546           * The following methods are used to handle overflowing modals
3547           */
3548          _adjustDialog() {
3549            const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
3550            const scrollbarWidth = this._scrollBar.getWidth();
3551            const isBodyOverflowing = scrollbarWidth > 0;
3552            if (isBodyOverflowing && !isModalOverflowing) {
3553              const property = isRTL() ? "paddingLeft" : "paddingRight";
3554              this._element.style[property] = `${scrollbarWidth}px`;
3555            }
3556            if (!isBodyOverflowing && isModalOverflowing) {
3557              const property = isRTL() ? "paddingRight" : "paddingLeft";
3558              this._element.style[property] = `${scrollbarWidth}px`;
3559            }
3560          }
3561          _resetAdjustments() {
3562            this._element.style.paddingLeft = "";
3563            this._element.style.paddingRight = "";
3564          }
3565          // Static
3566          static jQueryInterface(config3, relatedTarget) {
3567            return this.each(function() {
3568              const data = Modal.getOrCreateInstance(this, config3);
3569              if (typeof config3 !== "string") {
3570                return;
3571              }
3572              if (typeof data[config3] === "undefined") {
3573                throw new TypeError(`No method named "${config3}"`);
3574              }
3575              data[config3](relatedTarget);
3576            });
3577          }
3578        }
3579        EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function(event) {
3580          const target = SelectorEngine.getElementFromSelector(this);
3581          if (["A", "AREA"].includes(this.tagName)) {
3582            event.preventDefault();
3583          }
3584          EventHandler.one(target, EVENT_SHOW$4, (showEvent) => {
3585            if (showEvent.defaultPrevented) {
3586              return;
3587            }
3588            EventHandler.one(target, EVENT_HIDDEN$4, () => {
3589              if (isVisible(this)) {
3590                this.focus();
3591              }
3592            });
3593          });
3594          const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1);
3595          if (alreadyOpen) {
3596            Modal.getInstance(alreadyOpen).hide();
3597          }
3598          const data = Modal.getOrCreateInstance(target);
3599          data.toggle(this);
3600        });
3601        enableDismissTrigger(Modal);
3602        defineJQueryPlugin(Modal);
3603        const NAME$6 = "offcanvas";
3604        const DATA_KEY$3 = "bs.offcanvas";
3605        const EVENT_KEY$3 = `.${DATA_KEY$3}`;
3606        const DATA_API_KEY$1 = ".data-api";
3607        const EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$3}${DATA_API_KEY$1}`;
3608        const ESCAPE_KEY = "Escape";
3609        const CLASS_NAME_SHOW$3 = "show";
3610        const CLASS_NAME_SHOWING$1 = "showing";
3611        const CLASS_NAME_HIDING = "hiding";
3612        const CLASS_NAME_BACKDROP = "offcanvas-backdrop";
3613        const OPEN_SELECTOR = ".offcanvas.show";
3614        const EVENT_SHOW$3 = `show${EVENT_KEY$3}`;
3615        const EVENT_SHOWN$3 = `shown${EVENT_KEY$3}`;
3616        const EVENT_HIDE$3 = `hide${EVENT_KEY$3}`;
3617        const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$3}`;
3618        const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$3}`;
3619        const EVENT_RESIZE = `resize${EVENT_KEY$3}`;
3620        const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$3}${DATA_API_KEY$1}`;
3621        const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$3}`;
3622        const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]';
3623        const Default$5 = {
3624          backdrop: true,
3625          keyboard: true,
3626          scroll: false
3627        };
3628        const DefaultType$5 = {
3629          backdrop: "(boolean|string)",
3630          keyboard: "boolean",
3631          scroll: "boolean"
3632        };
3633        class Offcanvas extends BaseComponent {
3634          constructor(element, config3) {
3635            super(element, config3);
3636            this._isShown = false;
3637            this._backdrop = this._initializeBackDrop();
3638            this._focustrap = this._initializeFocusTrap();
3639            this._addEventListeners();
3640          }
3641          // Getters
3642          static get Default() {
3643            return Default$5;
3644          }
3645          static get DefaultType() {
3646            return DefaultType$5;
3647          }
3648          static get NAME() {
3649            return NAME$6;
3650          }
3651          // Public
3652          toggle(relatedTarget) {
3653            return this._isShown ? this.hide() : this.show(relatedTarget);
3654          }
3655          show(relatedTarget) {
3656            if (this._isShown) {
3657              return;
3658            }
3659            const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {
3660              relatedTarget
3661            });
3662            if (showEvent.defaultPrevented) {
3663              return;
3664            }
3665            this._isShown = true;
3666            this._backdrop.show();
3667            if (!this._config.scroll) {
3668              new ScrollBarHelper().hide();
3669            }
3670            this._element.setAttribute("aria-modal", true);
3671            this._element.setAttribute("role", "dialog");
3672            this._element.classList.add(CLASS_NAME_SHOWING$1);
3673            const completeCallBack = () => {
3674              if (!this._config.scroll || this._config.backdrop) {
3675                this._focustrap.activate();
3676              }
3677              this._element.classList.add(CLASS_NAME_SHOW$3);
3678              this._element.classList.remove(CLASS_NAME_SHOWING$1);
3679              EventHandler.trigger(this._element, EVENT_SHOWN$3, {
3680                relatedTarget
3681              });
3682            };
3683            this._queueCallback(completeCallBack, this._element, true);
3684          }
3685          hide() {
3686            if (!this._isShown) {
3687              return;
3688            }
3689            const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3);
3690            if (hideEvent.defaultPrevented) {
3691              return;
3692            }
3693            this._focustrap.deactivate();
3694            this._element.blur();
3695            this._isShown = false;
3696            this._element.classList.add(CLASS_NAME_HIDING);
3697            this._backdrop.hide();
3698            const completeCallback = () => {
3699              this._element.classList.remove(CLASS_NAME_SHOW$3, CLASS_NAME_HIDING);
3700              this._element.removeAttribute("aria-modal");
3701              this._element.removeAttribute("role");
3702              if (!this._config.scroll) {
3703                new ScrollBarHelper().reset();
3704              }
3705              EventHandler.trigger(this._element, EVENT_HIDDEN$3);
3706            };
3707            this._queueCallback(completeCallback, this._element, true);
3708          }
3709          dispose() {
3710            this._backdrop.dispose();
3711            this._focustrap.deactivate();
3712            super.dispose();
3713          }
3714          // Private
3715          _initializeBackDrop() {
3716            const clickCallback = () => {
3717              if (this._config.backdrop === "static") {
3718                EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
3719                return;
3720              }
3721              this.hide();
3722            };
3723            const isVisible2 = Boolean(this._config.backdrop);
3724            return new Backdrop({
3725              className: CLASS_NAME_BACKDROP,
3726              isVisible: isVisible2,
3727              isAnimated: true,
3728              rootElement: this._element.parentNode,
3729              clickCallback: isVisible2 ? clickCallback : null
3730            });
3731          }
3732          _initializeFocusTrap() {
3733            return new FocusTrap({
3734              trapElement: this._element
3735            });
3736          }
3737          _addEventListeners() {
3738            EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, (event) => {
3739              if (event.key !== ESCAPE_KEY) {
3740                return;
3741              }
3742              if (this._config.keyboard) {
3743                this.hide();
3744                return;
3745              }
3746              EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
3747            });
3748          }
3749          // Static
3750          static jQueryInterface(config3) {
3751            return this.each(function() {
3752              const data = Offcanvas.getOrCreateInstance(this, config3);
3753              if (typeof config3 !== "string") {
3754                return;
3755              }
3756              if (data[config3] === void 0 || config3.startsWith("_") || config3 === "constructor") {
3757                throw new TypeError(`No method named "${config3}"`);
3758              }
3759              data[config3](this);
3760            });
3761          }
3762        }
3763        EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function(event) {
3764          const target = SelectorEngine.getElementFromSelector(this);
3765          if (["A", "AREA"].includes(this.tagName)) {
3766            event.preventDefault();
3767          }
3768          if (isDisabled(this)) {
3769            return;
3770          }
3771          EventHandler.one(target, EVENT_HIDDEN$3, () => {
3772            if (isVisible(this)) {
3773              this.focus();
3774            }
3775          });
3776          const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);
3777          if (alreadyOpen && alreadyOpen !== target) {
3778            Offcanvas.getInstance(alreadyOpen).hide();
3779          }
3780          const data = Offcanvas.getOrCreateInstance(target);
3781          data.toggle(this);
3782        });
3783        EventHandler.on(window, EVENT_LOAD_DATA_API$2, () => {
3784          for (const selector3 of SelectorEngine.find(OPEN_SELECTOR)) {
3785            Offcanvas.getOrCreateInstance(selector3).show();
3786          }
3787        });
3788        EventHandler.on(window, EVENT_RESIZE, () => {
3789          for (const element of SelectorEngine.find("[aria-modal][class*=show][class*=offcanvas-]")) {
3790            if (getComputedStyle(element).position !== "fixed") {
3791              Offcanvas.getOrCreateInstance(element).hide();
3792            }
3793          }
3794        });
3795        enableDismissTrigger(Offcanvas);
3796        defineJQueryPlugin(Offcanvas);
3797        const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
3798        const DefaultAllowlist = {
3799          // Global attributes allowed on any supplied element below.
3800          "*": ["class", "dir", "id", "lang", "role", ARIA_ATTRIBUTE_PATTERN],
3801          a: ["target", "href", "title", "rel"],
3802          area: [],
3803          b: [],
3804          br: [],
3805          col: [],
3806          code: [],
3807          dd: [],
3808          div: [],
3809          dl: [],
3810          dt: [],
3811          em: [],
3812          hr: [],
3813          h1: [],
3814          h2: [],
3815          h3: [],
3816          h4: [],
3817          h5: [],
3818          h6: [],
3819          i: [],
3820          img: ["src", "srcset", "alt", "title", "width", "height"],
3821          li: [],
3822          ol: [],
3823          p: [],
3824          pre: [],
3825          s: [],
3826          small: [],
3827          span: [],
3828          sub: [],
3829          sup: [],
3830          strong: [],
3831          u: [],
3832          ul: []
3833        };
3834        const uriAttributes = /* @__PURE__ */ new Set(["background", "cite", "href", "itemtype", "longdesc", "poster", "src", "xlink:href"]);
3835        const SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/i;
3836        const allowedAttribute = (attribute, allowedAttributeList) => {
3837          const attributeName = attribute.nodeName.toLowerCase();
3838          if (allowedAttributeList.includes(attributeName)) {
3839            if (uriAttributes.has(attributeName)) {
3840              return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue));
3841            }
3842            return true;
3843          }
3844          return allowedAttributeList.filter((attributeRegex) => attributeRegex instanceof RegExp).some((regex) => regex.test(attributeName));
3845        };
3846        function sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) {
3847          if (!unsafeHtml.length) {
3848            return unsafeHtml;
3849          }
3850          if (sanitizeFunction && typeof sanitizeFunction === "function") {
3851            return sanitizeFunction(unsafeHtml);
3852          }
3853          const domParser = new window.DOMParser();
3854          const createdDocument = domParser.parseFromString(unsafeHtml, "text/html");
3855          const elements = [].concat(...createdDocument.body.querySelectorAll("*"));
3856          for (const element of elements) {
3857            const elementName = element.nodeName.toLowerCase();
3858            if (!Object.keys(allowList).includes(elementName)) {
3859              element.remove();
3860              continue;
3861            }
3862            const attributeList = [].concat(...element.attributes);
3863            const allowedAttributes = [].concat(allowList["*"] || [], allowList[elementName] || []);
3864            for (const attribute of attributeList) {
3865              if (!allowedAttribute(attribute, allowedAttributes)) {
3866                element.removeAttribute(attribute.nodeName);
3867              }
3868            }
3869          }
3870          return createdDocument.body.innerHTML;
3871        }
3872        const NAME$5 = "TemplateFactory";
3873        const Default$4 = {
3874          allowList: DefaultAllowlist,
3875          content: {},
3876          // { selector : text ,  selector2 : text2 , }
3877          extraClass: "",
3878          html: false,
3879          sanitize: true,
3880          sanitizeFn: null,
3881          template: "<div></div>"
3882        };
3883        const DefaultType$4 = {
3884          allowList: "object",
3885          content: "object",
3886          extraClass: "(string|function)",
3887          html: "boolean",
3888          sanitize: "boolean",
3889          sanitizeFn: "(null|function)",
3890          template: "string"
3891        };
3892        const DefaultContentType = {
3893          entry: "(string|element|function|null)",
3894          selector: "(string|element)"
3895        };
3896        class TemplateFactory extends Config {
3897          constructor(config3) {
3898            super();
3899            this._config = this._getConfig(config3);
3900          }
3901          // Getters
3902          static get Default() {
3903            return Default$4;
3904          }
3905          static get DefaultType() {
3906            return DefaultType$4;
3907          }
3908          static get NAME() {
3909            return NAME$5;
3910          }
3911          // Public
3912          getContent() {
3913            return Object.values(this._config.content).map((config3) => this._resolvePossibleFunction(config3)).filter(Boolean);
3914          }
3915          hasContent() {
3916            return this.getContent().length > 0;
3917          }
3918          changeContent(content) {
3919            this._checkContent(content);
3920            this._config.content = {
3921              ...this._config.content,
3922              ...content
3923            };
3924            return this;
3925          }
3926          toHtml() {
3927            const templateWrapper = document.createElement("div");
3928            templateWrapper.innerHTML = this._maybeSanitize(this._config.template);
3929            for (const [selector3, text] of Object.entries(this._config.content)) {
3930              this._setContent(templateWrapper, text, selector3);
3931            }
3932            const template = templateWrapper.children[0];
3933            const extraClass = this._resolvePossibleFunction(this._config.extraClass);
3934            if (extraClass) {
3935              template.classList.add(...extraClass.split(" "));
3936            }
3937            return template;
3938          }
3939          // Private
3940          _typeCheckConfig(config3) {
3941            super._typeCheckConfig(config3);
3942            this._checkContent(config3.content);
3943          }
3944          _checkContent(arg) {
3945            for (const [selector3, content] of Object.entries(arg)) {
3946              super._typeCheckConfig({
3947                selector: selector3,
3948                entry: content
3949              }, DefaultContentType);
3950            }
3951          }
3952          _setContent(template, content, selector3) {
3953            const templateElement = SelectorEngine.findOne(selector3, template);
3954            if (!templateElement) {
3955              return;
3956            }
3957            content = this._resolvePossibleFunction(content);
3958            if (!content) {
3959              templateElement.remove();
3960              return;
3961            }
3962            if (isElement(content)) {
3963              this._putElementInTemplate(getElement(content), templateElement);
3964              return;
3965            }
3966            if (this._config.html) {
3967              templateElement.innerHTML = this._maybeSanitize(content);
3968              return;
3969            }
3970            templateElement.textContent = content;
3971          }
3972          _maybeSanitize(arg) {
3973            return this._config.sanitize ? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn) : arg;
3974          }
3975          _resolvePossibleFunction(arg) {
3976            return execute2(arg, [void 0, this]);
3977          }
3978          _putElementInTemplate(element, templateElement) {
3979            if (this._config.html) {
3980              templateElement.innerHTML = "";
3981              templateElement.append(element);
3982              return;
3983            }
3984            templateElement.textContent = element.textContent;
3985          }
3986        }
3987        const NAME$4 = "tooltip";
3988        const DISALLOWED_ATTRIBUTES = /* @__PURE__ */ new Set(["sanitize", "allowList", "sanitizeFn"]);
3989        const CLASS_NAME_FADE$2 = "fade";
3990        const CLASS_NAME_MODAL = "modal";
3991        const CLASS_NAME_SHOW$2 = "show";
3992        const SELECTOR_TOOLTIP_INNER = ".tooltip-inner";
3993        const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`;
3994        const EVENT_MODAL_HIDE = "hide.bs.modal";
3995        const TRIGGER_HOVER = "hover";
3996        const TRIGGER_FOCUS = "focus";
3997        const TRIGGER_CLICK = "click";
3998        const TRIGGER_MANUAL = "manual";
3999        const EVENT_HIDE$2 = "hide";
4000        const EVENT_HIDDEN$2 = "hidden";
4001        const EVENT_SHOW$2 = "show";
4002        const EVENT_SHOWN$2 = "shown";
4003        const EVENT_INSERTED = "inserted";
4004        const EVENT_CLICK$1 = "click";
4005        const EVENT_FOCUSIN$1 = "focusin";
4006        const EVENT_FOCUSOUT$1 = "focusout";
4007        const EVENT_MOUSEENTER = "mouseenter";
4008        const EVENT_MOUSELEAVE = "mouseleave";
4009        const AttachmentMap = {
4010          AUTO: "auto",
4011          TOP: "top",
4012          RIGHT: isRTL() ? "left" : "right",
4013          BOTTOM: "bottom",
4014          LEFT: isRTL() ? "right" : "left"
4015        };
4016        const Default$3 = {
4017          allowList: DefaultAllowlist,
4018          animation: true,
4019          boundary: "clippingParents",
4020          container: false,
4021          customClass: "",
4022          delay: 0,
4023          fallbackPlacements: ["top", "right", "bottom", "left"],
4024          html: false,
4025          offset: [0, 6],
4026          placement: "top",
4027          popperConfig: null,
4028          sanitize: true,
4029          sanitizeFn: null,
4030          selector: false,
4031          template: '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
4032          title: "",
4033          trigger: "hover focus"
4034        };
4035        const DefaultType$3 = {
4036          allowList: "object",
4037          animation: "boolean",
4038          boundary: "(string|element)",
4039          container: "(string|element|boolean)",
4040          customClass: "(string|function)",
4041          delay: "(number|object)",
4042          fallbackPlacements: "array",
4043          html: "boolean",
4044          offset: "(array|string|function)",
4045          placement: "(string|function)",
4046          popperConfig: "(null|object|function)",
4047          sanitize: "boolean",
4048          sanitizeFn: "(null|function)",
4049          selector: "(string|boolean)",
4050          template: "string",
4051          title: "(string|element|function)",
4052          trigger: "string"
4053        };
4054        class Tooltip2 extends BaseComponent {
4055          constructor(element, config3) {
4056            if (typeof Popper__namespace === "undefined") {
4057              throw new TypeError("Bootstrap's tooltips require Popper (https://popper.js.org/docs/v2/)");
4058            }
4059            super(element, config3);
4060            this._isEnabled = true;
4061            this._timeout = 0;
4062            this._isHovered = null;
4063            this._activeTrigger = {};
4064            this._popper = null;
4065            this._templateFactory = null;
4066            this._newContent = null;
4067            this.tip = null;
4068            this._setListeners();
4069            if (!this._config.selector) {
4070              this._fixTitle();
4071            }
4072          }
4073          // Getters
4074          static get Default() {
4075            return Default$3;
4076          }
4077          static get DefaultType() {
4078            return DefaultType$3;
4079          }
4080          static get NAME() {
4081            return NAME$4;
4082          }
4083          // Public
4084          enable() {
4085            this._isEnabled = true;
4086          }
4087          disable() {
4088            this._isEnabled = false;
4089          }
4090          toggleEnabled() {
4091            this._isEnabled = !this._isEnabled;
4092          }
4093          toggle() {
4094            if (!this._isEnabled) {
4095              return;
4096            }
4097            if (this._isShown()) {
4098              this._leave();
4099              return;
4100            }
4101            this._enter();
4102          }
4103          dispose() {
4104            clearTimeout(this._timeout);
4105            EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
4106            if (this._element.getAttribute("data-bs-original-title")) {
4107              this._element.setAttribute("title", this._element.getAttribute("data-bs-original-title"));
4108            }
4109            this._disposePopper();
4110            super.dispose();
4111          }
4112          show() {
4113            if (this._element.style.display === "none") {
4114              throw new Error("Please use show on visible elements");
4115            }
4116            if (!(this._isWithContent() && this._isEnabled)) {
4117              return;
4118            }
4119            const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW$2));
4120            const shadowRoot = findShadowRoot(this._element);
4121            const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element);
4122            if (showEvent.defaultPrevented || !isInTheDom) {
4123              return;
4124            }
4125            this._disposePopper();
4126            const tip = this._getTipElement();
4127            this._element.setAttribute("aria-describedby", tip.getAttribute("id"));
4128            const {
4129              container
4130            } = this._config;
4131            if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
4132              container.append(tip);
4133              EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED));
4134            }
4135            this._popper = this._createPopper(tip);
4136            tip.classList.add(CLASS_NAME_SHOW$2);
4137            if ("ontouchstart" in document.documentElement) {
4138              for (const element of [].concat(...document.body.children)) {
4139                EventHandler.on(element, "mouseover", noop);
4140              }
4141            }
4142            const complete = () => {
4143              EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOWN$2));
4144              if (this._isHovered === false) {
4145                this._leave();
4146              }
4147              this._isHovered = false;
4148            };
4149            this._queueCallback(complete, this.tip, this._isAnimated());
4150          }
4151          hide() {
4152            if (!this._isShown()) {
4153              return;
4154            }
4155            const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE$2));
4156            if (hideEvent.defaultPrevented) {
4157              return;
4158            }
4159            const tip = this._getTipElement();
4160            tip.classList.remove(CLASS_NAME_SHOW$2);
4161            if ("ontouchstart" in document.documentElement) {
4162              for (const element of [].concat(...document.body.children)) {
4163                EventHandler.off(element, "mouseover", noop);
4164              }
4165            }
4166            this._activeTrigger[TRIGGER_CLICK] = false;
4167            this._activeTrigger[TRIGGER_FOCUS] = false;
4168            this._activeTrigger[TRIGGER_HOVER] = false;
4169            this._isHovered = null;
4170            const complete = () => {
4171              if (this._isWithActiveTrigger()) {
4172                return;
4173              }
4174              if (!this._isHovered) {
4175                this._disposePopper();
4176              }
4177              this._element.removeAttribute("aria-describedby");
4178              EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDDEN$2));
4179            };
4180            this._queueCallback(complete, this.tip, this._isAnimated());
4181          }
4182          update() {
4183            if (this._popper) {
4184              this._popper.update();
4185            }
4186          }
4187          // Protected
4188          _isWithContent() {
4189            return Boolean(this._getTitle());
4190          }
4191          _getTipElement() {
4192            if (!this.tip) {
4193              this.tip = this._createTipElement(this._newContent || this._getContentForTemplate());
4194            }
4195            return this.tip;
4196          }
4197          _createTipElement(content) {
4198            const tip = this._getTemplateFactory(content).toHtml();
4199            if (!tip) {
4200              return null;
4201            }
4202            tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2);
4203            tip.classList.add(`bs-${this.constructor.NAME}-auto`);
4204            const tipId = getUID(this.constructor.NAME).toString();
4205            tip.setAttribute("id", tipId);
4206            if (this._isAnimated()) {
4207              tip.classList.add(CLASS_NAME_FADE$2);
4208            }
4209            return tip;
4210          }
4211          setContent(content) {
4212            this._newContent = content;
4213            if (this._isShown()) {
4214              this._disposePopper();
4215              this.show();
4216            }
4217          }
4218          _getTemplateFactory(content) {
4219            if (this._templateFactory) {
4220              this._templateFactory.changeContent(content);
4221            } else {
4222              this._templateFactory = new TemplateFactory({
4223                ...this._config,
4224                // the `content` var has to be after `this._config`
4225                // to override config.content in case of popover
4226                content,
4227                extraClass: this._resolvePossibleFunction(this._config.customClass)
4228              });
4229            }
4230            return this._templateFactory;
4231          }
4232          _getContentForTemplate() {
4233            return {
4234              [SELECTOR_TOOLTIP_INNER]: this._getTitle()
4235            };
4236          }
4237          _getTitle() {
4238            return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute("data-bs-original-title");
4239          }
4240          // Private
4241          _initializeOnDelegatedTarget(event) {
4242            return this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig());
4243          }
4244          _isAnimated() {
4245            return this._config.animation || this.tip && this.tip.classList.contains(CLASS_NAME_FADE$2);
4246          }
4247          _isShown() {
4248            return this.tip && this.tip.classList.contains(CLASS_NAME_SHOW$2);
4249          }
4250          _createPopper(tip) {
4251            const placement = execute2(this._config.placement, [this, tip, this._element]);
4252            const attachment = AttachmentMap[placement.toUpperCase()];
4253            return Popper__namespace.createPopper(this._element, tip, this._getPopperConfig(attachment));
4254          }
4255          _getOffset() {
4256            const {
4257              offset
4258            } = this._config;
4259            if (typeof offset === "string") {
4260              return offset.split(",").map((value) => Number.parseInt(value, 10));
4261            }
4262            if (typeof offset === "function") {
4263              return (popperData) => offset(popperData, this._element);
4264            }
4265            return offset;
4266          }
4267          _resolvePossibleFunction(arg) {
4268            return execute2(arg, [this._element, this._element]);
4269          }
4270          _getPopperConfig(attachment) {
4271            const defaultBsPopperConfig = {
4272              placement: attachment,
4273              modifiers: [{
4274                name: "flip",
4275                options: {
4276                  fallbackPlacements: this._config.fallbackPlacements
4277                }
4278              }, {
4279                name: "offset",
4280                options: {
4281                  offset: this._getOffset()
4282                }
4283              }, {
4284                name: "preventOverflow",
4285                options: {
4286                  boundary: this._config.boundary
4287                }
4288              }, {
4289                name: "arrow",
4290                options: {
4291                  element: `.${this.constructor.NAME}-arrow`
4292                }
4293              }, {
4294                name: "preSetPlacement",
4295                enabled: true,
4296                phase: "beforeMain",
4297                fn: (data) => {
4298                  this._getTipElement().setAttribute("data-popper-placement", data.state.placement);
4299                }
4300              }]
4301            };
4302            return {
4303              ...defaultBsPopperConfig,
4304              ...execute2(this._config.popperConfig, [void 0, defaultBsPopperConfig])
4305            };
4306          }
4307          _setListeners() {
4308            const triggers = this._config.trigger.split(" ");
4309            for (const trigger of triggers) {
4310              if (trigger === "click") {
4311                EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK$1), this._config.selector, (event) => {
4312                  const context3 = this._initializeOnDelegatedTarget(event);
4313                  context3._activeTrigger[TRIGGER_CLICK] = !(context3._isShown() && context3._activeTrigger[TRIGGER_CLICK]);
4314                  context3.toggle();
4315                });
4316              } else if (trigger !== TRIGGER_MANUAL) {
4317                const eventIn = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSEENTER) : this.constructor.eventName(EVENT_FOCUSIN$1);
4318                const eventOut = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSELEAVE) : this.constructor.eventName(EVENT_FOCUSOUT$1);
4319                EventHandler.on(this._element, eventIn, this._config.selector, (event) => {
4320                  const context3 = this._initializeOnDelegatedTarget(event);
4321                  context3._activeTrigger[event.type === "focusin" ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;
4322                  context3._enter();
4323                });
4324                EventHandler.on(this._element, eventOut, this._config.selector, (event) => {
4325                  const context3 = this._initializeOnDelegatedTarget(event);
4326                  context3._activeTrigger[event.type === "focusout" ? TRIGGER_FOCUS : TRIGGER_HOVER] = context3._element.contains(event.relatedTarget);
4327                  context3._leave();
4328                });
4329              }
4330            }
4331            this._hideModalHandler = () => {
4332              if (this._element) {
4333                this.hide();
4334              }
4335            };
4336            EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
4337          }
4338          _fixTitle() {
4339            const title = this._element.getAttribute("title");
4340            if (!title) {
4341              return;
4342            }
4343            if (!this._element.getAttribute("aria-label") && !this._element.textContent.trim()) {
4344              this._element.setAttribute("aria-label", title);
4345            }
4346            this._element.setAttribute("data-bs-original-title", title);
4347            this._element.removeAttribute("title");
4348          }
4349          _enter() {
4350            if (this._isShown() || this._isHovered) {
4351              this._isHovered = true;
4352              return;
4353            }
4354            this._isHovered = true;
4355            this._setTimeout(() => {
4356              if (this._isHovered) {
4357                this.show();
4358              }
4359            }, this._config.delay.show);
4360          }
4361          _leave() {
4362            if (this._isWithActiveTrigger()) {
4363              return;
4364            }
4365            this._isHovered = false;
4366            this._setTimeout(() => {
4367              if (!this._isHovered) {
4368                this.hide();
4369              }
4370            }, this._config.delay.hide);
4371          }
4372          _setTimeout(handler, timeout) {
4373            clearTimeout(this._timeout);
4374            this._timeout = setTimeout(handler, timeout);
4375          }
4376          _isWithActiveTrigger() {
4377            return Object.values(this._activeTrigger).includes(true);
4378          }
4379          _getConfig(config3) {
4380            const dataAttributes = Manipulator.getDataAttributes(this._element);
4381            for (const dataAttribute of Object.keys(dataAttributes)) {
4382              if (DISALLOWED_ATTRIBUTES.has(dataAttribute)) {
4383                delete dataAttributes[dataAttribute];
4384              }
4385            }
4386            config3 = {
4387              ...dataAttributes,
4388              ...typeof config3 === "object" && config3 ? config3 : {}
4389            };
4390            config3 = this._mergeConfigObj(config3);
4391            config3 = this._configAfterMerge(config3);
4392            this._typeCheckConfig(config3);
4393            return config3;
4394          }
4395          _configAfterMerge(config3) {
4396            config3.container = config3.container === false ? document.body : getElement(config3.container);
4397            if (typeof config3.delay === "number") {
4398              config3.delay = {
4399                show: config3.delay,
4400                hide: config3.delay
4401              };
4402            }
4403            if (typeof config3.title === "number") {
4404              config3.title = config3.title.toString();
4405            }
4406            if (typeof config3.content === "number") {
4407              config3.content = config3.content.toString();
4408            }
4409            return config3;
4410          }
4411          _getDelegateConfig() {
4412            const config3 = {};
4413            for (const [key, value] of Object.entries(this._config)) {
4414              if (this.constructor.Default[key] !== value) {
4415                config3[key] = value;
4416              }
4417            }
4418            config3.selector = false;
4419            config3.trigger = "manual";
4420            return config3;
4421          }
4422          _disposePopper() {
4423            if (this._popper) {
4424              this._popper.destroy();
4425              this._popper = null;
4426            }
4427            if (this.tip) {
4428              this.tip.remove();
4429              this.tip = null;
4430            }
4431          }
4432          // Static
4433          static jQueryInterface(config3) {
4434            return this.each(function() {
4435              const data = Tooltip2.getOrCreateInstance(this, config3);
4436              if (typeof config3 !== "string") {
4437                return;
4438              }
4439              if (typeof data[config3] === "undefined") {
4440                throw new TypeError(`No method named "${config3}"`);
4441              }
4442              data[config3]();
4443            });
4444          }
4445        }
4446        defineJQueryPlugin(Tooltip2);
4447        const NAME$3 = "popover";
4448        const SELECTOR_TITLE = ".popover-header";
4449        const SELECTOR_CONTENT = ".popover-body";
4450        const Default$2 = {
4451          ...Tooltip2.Default,
4452          content: "",
4453          offset: [0, 8],
4454          placement: "right",
4455          template: '<div class="popover" role="tooltip"><div class="popover-arrow"></div><h3 class="popover-header"></h3><div class="popover-body"></div></div>',
4456          trigger: "click"
4457        };
4458        const DefaultType$2 = {
4459          ...Tooltip2.DefaultType,
4460          content: "(null|string|element|function)"
4461        };
4462        class Popover extends Tooltip2 {
4463          // Getters
4464          static get Default() {
4465            return Default$2;
4466          }
4467          static get DefaultType() {
4468            return DefaultType$2;
4469          }
4470          static get NAME() {
4471            return NAME$3;
4472          }
4473          // Overrides
4474          _isWithContent() {
4475            return this._getTitle() || this._getContent();
4476          }
4477          // Private
4478          _getContentForTemplate() {
4479            return {
4480              [SELECTOR_TITLE]: this._getTitle(),
4481              [SELECTOR_CONTENT]: this._getContent()
4482            };
4483          }
4484          _getContent() {
4485            return this._resolvePossibleFunction(this._config.content);
4486          }
4487          // Static
4488          static jQueryInterface(config3) {
4489            return this.each(function() {
4490              const data = Popover.getOrCreateInstance(this, config3);
4491              if (typeof config3 !== "string") {
4492                return;
4493              }
4494              if (typeof data[config3] === "undefined") {
4495                throw new TypeError(`No method named "${config3}"`);
4496              }
4497              data[config3]();
4498            });
4499          }
4500        }
4501        defineJQueryPlugin(Popover);
4502        const NAME$2 = "scrollspy";
4503        const DATA_KEY$2 = "bs.scrollspy";
4504        const EVENT_KEY$2 = `.${DATA_KEY$2}`;
4505        const DATA_API_KEY = ".data-api";
4506        const EVENT_ACTIVATE = `activate${EVENT_KEY$2}`;
4507        const EVENT_CLICK = `click${EVENT_KEY$2}`;
4508        const EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$2}${DATA_API_KEY}`;
4509        const CLASS_NAME_DROPDOWN_ITEM = "dropdown-item";
4510        const CLASS_NAME_ACTIVE$1 = "active";
4511        const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]';
4512        const SELECTOR_TARGET_LINKS = "[href]";
4513        const SELECTOR_NAV_LIST_GROUP = ".nav, .list-group";
4514        const SELECTOR_NAV_LINKS = ".nav-link";
4515        const SELECTOR_NAV_ITEMS = ".nav-item";
4516        const SELECTOR_LIST_ITEMS = ".list-group-item";
4517        const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`;
4518        const SELECTOR_DROPDOWN = ".dropdown";
4519        const SELECTOR_DROPDOWN_TOGGLE$1 = ".dropdown-toggle";
4520        const Default$1 = {
4521          offset: null,
4522          // TODO: v6 @deprecated, keep it for backwards compatibility reasons
4523          rootMargin: "0px 0px -25%",
4524          smoothScroll: false,
4525          target: null,
4526          threshold: [0.1, 0.5, 1]
4527        };
4528        const DefaultType$1 = {
4529          offset: "(number|null)",
4530          // TODO v6 @deprecated, keep it for backwards compatibility reasons
4531          rootMargin: "string",
4532          smoothScroll: "boolean",
4533          target: "element",
4534          threshold: "array"
4535        };
4536        class ScrollSpy extends BaseComponent {
4537          constructor(element, config3) {
4538            super(element, config3);
4539            this._targetLinks = /* @__PURE__ */ new Map();
4540            this._observableSections = /* @__PURE__ */ new Map();
4541            this._rootElement = getComputedStyle(this._element).overflowY === "visible" ? null : this._element;
4542            this._activeTarget = null;
4543            this._observer = null;
4544            this._previousScrollData = {
4545              visibleEntryTop: 0,
4546              parentScrollTop: 0
4547            };
4548            this.refresh();
4549          }
4550          // Getters
4551          static get Default() {
4552            return Default$1;
4553          }
4554          static get DefaultType() {
4555            return DefaultType$1;
4556          }
4557          static get NAME() {
4558            return NAME$2;
4559          }
4560          // Public
4561          refresh() {
4562            this._initializeTargetsAndObservables();
4563            this._maybeEnableSmoothScroll();
4564            if (this._observer) {
4565              this._observer.disconnect();
4566            } else {
4567              this._observer = this._getNewObserver();
4568            }
4569            for (const section of this._observableSections.values()) {
4570              this._observer.observe(section);
4571            }
4572          }
4573          dispose() {
4574            this._observer.disconnect();
4575            super.dispose();
4576          }
4577          // Private
4578          _configAfterMerge(config3) {
4579            config3.target = getElement(config3.target) || document.body;
4580            config3.rootMargin = config3.offset ? `${config3.offset}px 0px -30%` : config3.rootMargin;
4581            if (typeof config3.threshold === "string") {
4582              config3.threshold = config3.threshold.split(",").map((value) => Number.parseFloat(value));
4583            }
4584            return config3;
4585          }
4586          _maybeEnableSmoothScroll() {
4587            if (!this._config.smoothScroll) {
4588              return;
4589            }
4590            EventHandler.off(this._config.target, EVENT_CLICK);
4591            EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, (event) => {
4592              const observableSection = this._observableSections.get(event.target.hash);
4593              if (observableSection) {
4594                event.preventDefault();
4595                const root = this._rootElement || window;
4596                const height = observableSection.offsetTop - this._element.offsetTop;
4597                if (root.scrollTo) {
4598                  root.scrollTo({
4599                    top: height,
4600                    behavior: "smooth"
4601                  });
4602                  return;
4603                }
4604                root.scrollTop = height;
4605              }
4606            });
4607          }
4608          _getNewObserver() {
4609            const options = {
4610              root: this._rootElement,
4611              threshold: this._config.threshold,
4612              rootMargin: this._config.rootMargin
4613            };
4614            return new IntersectionObserver((entries) => this._observerCallback(entries), options);
4615          }
4616          // The logic of selection
4617          _observerCallback(entries) {
4618            const targetElement = (entry) => this._targetLinks.get(`#${entry.target.id}`);
4619            const activate = (entry) => {
4620              this._previousScrollData.visibleEntryTop = entry.target.offsetTop;
4621              this._process(targetElement(entry));
4622            };
4623            const parentScrollTop = (this._rootElement || document.documentElement).scrollTop;
4624            const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop;
4625            this._previousScrollData.parentScrollTop = parentScrollTop;
4626            for (const entry of entries) {
4627              if (!entry.isIntersecting) {
4628                this._activeTarget = null;
4629                this._clearActiveClass(targetElement(entry));
4630                continue;
4631              }
4632              const entryIsLowerThanPrevious = entry.target.offsetTop >= this._previousScrollData.visibleEntryTop;
4633              if (userScrollsDown && entryIsLowerThanPrevious) {
4634                activate(entry);
4635                if (!parentScrollTop) {
4636                  return;
4637                }
4638                continue;
4639              }
4640              if (!userScrollsDown && !entryIsLowerThanPrevious) {
4641                activate(entry);
4642              }
4643            }
4644          }
4645          _initializeTargetsAndObservables() {
4646            this._targetLinks = /* @__PURE__ */ new Map();
4647            this._observableSections = /* @__PURE__ */ new Map();
4648            const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target);
4649            for (const anchor of targetLinks) {
4650              if (!anchor.hash || isDisabled(anchor)) {
4651                continue;
4652              }
4653              const observableSection = SelectorEngine.findOne(decodeURI(anchor.hash), this._element);
4654              if (isVisible(observableSection)) {
4655                this._targetLinks.set(decodeURI(anchor.hash), anchor);
4656                this._observableSections.set(anchor.hash, observableSection);
4657              }
4658            }
4659          }
4660          _process(target) {
4661            if (this._activeTarget === target) {
4662              return;
4663            }
4664            this._clearActiveClass(this._config.target);
4665            this._activeTarget = target;
4666            target.classList.add(CLASS_NAME_ACTIVE$1);
4667            this._activateParents(target);
4668            EventHandler.trigger(this._element, EVENT_ACTIVATE, {
4669              relatedTarget: target
4670            });
4671          }
4672          _activateParents(target) {
4673            if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
4674              SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, target.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$1);
4675              return;
4676            }
4677            for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) {
4678              for (const item of SelectorEngine.prev(listGroup, SELECTOR_LINK_ITEMS)) {
4679                item.classList.add(CLASS_NAME_ACTIVE$1);
4680              }
4681            }
4682          }
4683          _clearActiveClass(parent) {
4684            parent.classList.remove(CLASS_NAME_ACTIVE$1);
4685            const activeNodes = SelectorEngine.find(`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE$1}`, parent);
4686            for (const node of activeNodes) {
4687              node.classList.remove(CLASS_NAME_ACTIVE$1);
4688            }
4689          }
4690          // Static
4691          static jQueryInterface(config3) {
4692            return this.each(function() {
4693              const data = ScrollSpy.getOrCreateInstance(this, config3);
4694              if (typeof config3 !== "string") {
4695                return;
4696              }
4697              if (data[config3] === void 0 || config3.startsWith("_") || config3 === "constructor") {
4698                throw new TypeError(`No method named "${config3}"`);
4699              }
4700              data[config3]();
4701            });
4702          }
4703        }
4704        EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => {
4705          for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) {
4706            ScrollSpy.getOrCreateInstance(spy);
4707          }
4708        });
4709        defineJQueryPlugin(ScrollSpy);
4710        const NAME$1 = "tab";
4711        const DATA_KEY$1 = "bs.tab";
4712        const EVENT_KEY$1 = `.${DATA_KEY$1}`;
4713        const EVENT_HIDE$1 = `hide${EVENT_KEY$1}`;
4714        const EVENT_HIDDEN$1 = `hidden${EVENT_KEY$1}`;
4715        const EVENT_SHOW$1 = `show${EVENT_KEY$1}`;
4716        const EVENT_SHOWN$1 = `shown${EVENT_KEY$1}`;
4717        const EVENT_CLICK_DATA_API = `click${EVENT_KEY$1}`;
4718        const EVENT_KEYDOWN = `keydown${EVENT_KEY$1}`;
4719        const EVENT_LOAD_DATA_API = `load${EVENT_KEY$1}`;
4720        const ARROW_LEFT_KEY = "ArrowLeft";
4721        const ARROW_RIGHT_KEY = "ArrowRight";
4722        const ARROW_UP_KEY = "ArrowUp";
4723        const ARROW_DOWN_KEY = "ArrowDown";
4724        const HOME_KEY = "Home";
4725        const END_KEY = "End";
4726        const CLASS_NAME_ACTIVE = "active";
4727        const CLASS_NAME_FADE$1 = "fade";
4728        const CLASS_NAME_SHOW$1 = "show";
4729        const CLASS_DROPDOWN = "dropdown";
4730        const SELECTOR_DROPDOWN_TOGGLE = ".dropdown-toggle";
4731        const SELECTOR_DROPDOWN_MENU = ".dropdown-menu";
4732        const NOT_SELECTOR_DROPDOWN_TOGGLE = `:not(${SELECTOR_DROPDOWN_TOGGLE})`;
4733        const SELECTOR_TAB_PANEL = '.list-group, .nav, [role="tablist"]';
4734        const SELECTOR_OUTER = ".nav-item, .list-group-item";
4735        const SELECTOR_INNER = `.nav-link${NOT_SELECTOR_DROPDOWN_TOGGLE}, .list-group-item${NOT_SELECTOR_DROPDOWN_TOGGLE}, [role="tab"]${NOT_SELECTOR_DROPDOWN_TOGGLE}`;
4736        const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]';
4737        const SELECTOR_INNER_ELEM = `${SELECTOR_INNER}, ${SELECTOR_DATA_TOGGLE}`;
4738        const SELECTOR_DATA_TOGGLE_ACTIVE = `.${CLASS_NAME_ACTIVE}[data-bs-toggle="tab"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="pill"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="list"]`;
4739        class Tab extends BaseComponent {
4740          constructor(element) {
4741            super(element);
4742            this._parent = this._element.closest(SELECTOR_TAB_PANEL);
4743            if (!this._parent) {
4744              return;
4745            }
4746            this._setInitialAttributes(this._parent, this._getChildren());
4747            EventHandler.on(this._element, EVENT_KEYDOWN, (event) => this._keydown(event));
4748          }
4749          // Getters
4750          static get NAME() {
4751            return NAME$1;
4752          }
4753          // Public
4754          show() {
4755            const innerElem = this._element;
4756            if (this._elemIsActive(innerElem)) {
4757              return;
4758            }
4759            const active = this._getActiveElem();
4760            const hideEvent = active ? EventHandler.trigger(active, EVENT_HIDE$1, {
4761              relatedTarget: innerElem
4762            }) : null;
4763            const showEvent = EventHandler.trigger(innerElem, EVENT_SHOW$1, {
4764              relatedTarget: active
4765            });
4766            if (showEvent.defaultPrevented || hideEvent && hideEvent.defaultPrevented) {
4767              return;
4768            }
4769            this._deactivate(active, innerElem);
4770            this._activate(innerElem, active);
4771          }
4772          // Private
4773          _activate(element, relatedElem) {
4774            if (!element) {
4775              return;
4776            }
4777            element.classList.add(CLASS_NAME_ACTIVE);
4778            this._activate(SelectorEngine.getElementFromSelector(element));
4779            const complete = () => {
4780              if (element.getAttribute("role") !== "tab") {
4781                element.classList.add(CLASS_NAME_SHOW$1);
4782                return;
4783              }
4784              element.removeAttribute("tabindex");
4785              element.setAttribute("aria-selected", true);
4786              this._toggleDropDown(element, true);
4787              EventHandler.trigger(element, EVENT_SHOWN$1, {
4788                relatedTarget: relatedElem
4789              });
4790            };
4791            this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1));
4792          }
4793          _deactivate(element, relatedElem) {
4794            if (!element) {
4795              return;
4796            }
4797            element.classList.remove(CLASS_NAME_ACTIVE);
4798            element.blur();
4799            this._deactivate(SelectorEngine.getElementFromSelector(element));
4800            const complete = () => {
4801              if (element.getAttribute("role") !== "tab") {
4802                element.classList.remove(CLASS_NAME_SHOW$1);
4803                return;
4804              }
4805              element.setAttribute("aria-selected", false);
4806              element.setAttribute("tabindex", "-1");
4807              this._toggleDropDown(element, false);
4808              EventHandler.trigger(element, EVENT_HIDDEN$1, {
4809                relatedTarget: relatedElem
4810              });
4811            };
4812            this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1));
4813          }
4814          _keydown(event) {
4815            if (![ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY, HOME_KEY, END_KEY].includes(event.key)) {
4816              return;
4817            }
4818            event.stopPropagation();
4819            event.preventDefault();
4820            const children = this._getChildren().filter((element) => !isDisabled(element));
4821            let nextActiveElement;
4822            if ([HOME_KEY, END_KEY].includes(event.key)) {
4823              nextActiveElement = children[event.key === HOME_KEY ? 0 : children.length - 1];
4824            } else {
4825              const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key);
4826              nextActiveElement = getNextActiveElement(children, event.target, isNext, true);
4827            }
4828            if (nextActiveElement) {
4829              nextActiveElement.focus({
4830                preventScroll: true
4831              });
4832              Tab.getOrCreateInstance(nextActiveElement).show();
4833            }
4834          }
4835          _getChildren() {
4836            return SelectorEngine.find(SELECTOR_INNER_ELEM, this._parent);
4837          }
4838          _getActiveElem() {
4839            return this._getChildren().find((child) => this._elemIsActive(child)) || null;
4840          }
4841          _setInitialAttributes(parent, children) {
4842            this._setAttributeIfNotExists(parent, "role", "tablist");
4843            for (const child of children) {
4844              this._setInitialAttributesOnChild(child);
4845            }
4846          }
4847          _setInitialAttributesOnChild(child) {
4848            child = this._getInnerElement(child);
4849            const isActive = this._elemIsActive(child);
4850            const outerElem = this._getOuterElement(child);
4851            child.setAttribute("aria-selected", isActive);
4852            if (outerElem !== child) {
4853              this._setAttributeIfNotExists(outerElem, "role", "presentation");
4854            }
4855            if (!isActive) {
4856              child.setAttribute("tabindex", "-1");
4857            }
4858            this._setAttributeIfNotExists(child, "role", "tab");
4859            this._setInitialAttributesOnTargetPanel(child);
4860          }
4861          _setInitialAttributesOnTargetPanel(child) {
4862            const target = SelectorEngine.getElementFromSelector(child);
4863            if (!target) {
4864              return;
4865            }
4866            this._setAttributeIfNotExists(target, "role", "tabpanel");
4867            if (child.id) {
4868              this._setAttributeIfNotExists(target, "aria-labelledby", `${child.id}`);
4869            }
4870          }
4871          _toggleDropDown(element, open) {
4872            const outerElem = this._getOuterElement(element);
4873            if (!outerElem.classList.contains(CLASS_DROPDOWN)) {
4874              return;
4875            }
4876            const toggle = (selector3, className) => {
4877              const element2 = SelectorEngine.findOne(selector3, outerElem);
4878              if (element2) {
4879                element2.classList.toggle(className, open);
4880              }
4881            };
4882            toggle(SELECTOR_DROPDOWN_TOGGLE, CLASS_NAME_ACTIVE);
4883            toggle(SELECTOR_DROPDOWN_MENU, CLASS_NAME_SHOW$1);
4884            outerElem.setAttribute("aria-expanded", open);
4885          }
4886          _setAttributeIfNotExists(element, attribute, value) {
4887            if (!element.hasAttribute(attribute)) {
4888              element.setAttribute(attribute, value);
4889            }
4890          }
4891          _elemIsActive(elem) {
4892            return elem.classList.contains(CLASS_NAME_ACTIVE);
4893          }
4894          // Try to get the inner element (usually the .nav-link)
4895          _getInnerElement(elem) {
4896            return elem.matches(SELECTOR_INNER_ELEM) ? elem : SelectorEngine.findOne(SELECTOR_INNER_ELEM, elem);
4897          }
4898          // Try to get the outer element (usually the .nav-item)
4899          _getOuterElement(elem) {
4900            return elem.closest(SELECTOR_OUTER) || elem;
4901          }
4902          // Static
4903          static jQueryInterface(config3) {
4904            return this.each(function() {
4905              const data = Tab.getOrCreateInstance(this);
4906              if (typeof config3 !== "string") {
4907                return;
4908              }
4909              if (data[config3] === void 0 || config3.startsWith("_") || config3 === "constructor") {
4910                throw new TypeError(`No method named "${config3}"`);
4911              }
4912              data[config3]();
4913            });
4914          }
4915        }
4916        EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function(event) {
4917          if (["A", "AREA"].includes(this.tagName)) {
4918            event.preventDefault();
4919          }
4920          if (isDisabled(this)) {
4921            return;
4922          }
4923          Tab.getOrCreateInstance(this).show();
4924        });
4925        EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
4926          for (const element of SelectorEngine.find(SELECTOR_DATA_TOGGLE_ACTIVE)) {
4927            Tab.getOrCreateInstance(element);
4928          }
4929        });
4930        defineJQueryPlugin(Tab);
4931        const NAME = "toast";
4932        const DATA_KEY = "bs.toast";
4933        const EVENT_KEY = `.${DATA_KEY}`;
4934        const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`;
4935        const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`;
4936        const EVENT_FOCUSIN = `focusin${EVENT_KEY}`;
4937        const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`;
4938        const EVENT_HIDE = `hide${EVENT_KEY}`;
4939        const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
4940        const EVENT_SHOW = `show${EVENT_KEY}`;
4941        const EVENT_SHOWN = `shown${EVENT_KEY}`;
4942        const CLASS_NAME_FADE = "fade";
4943        const CLASS_NAME_HIDE = "hide";
4944        const CLASS_NAME_SHOW = "show";
4945        const CLASS_NAME_SHOWING = "showing";
4946        const DefaultType = {
4947          animation: "boolean",
4948          autohide: "boolean",
4949          delay: "number"
4950        };
4951        const Default = {
4952          animation: true,
4953          autohide: true,
4954          delay: 5e3
4955        };
4956        class Toast extends BaseComponent {
4957          constructor(element, config3) {
4958            super(element, config3);
4959            this._timeout = null;
4960            this._hasMouseInteraction = false;
4961            this._hasKeyboardInteraction = false;
4962            this._setListeners();
4963          }
4964          // Getters
4965          static get Default() {
4966            return Default;
4967          }
4968          static get DefaultType() {
4969            return DefaultType;
4970          }
4971          static get NAME() {
4972            return NAME;
4973          }
4974          // Public
4975          show() {
4976            const showEvent = EventHandler.trigger(this._element, EVENT_SHOW);
4977            if (showEvent.defaultPrevented) {
4978              return;
4979            }
4980            this._clearTimeout();
4981            if (this._config.animation) {
4982              this._element.classList.add(CLASS_NAME_FADE);
4983            }
4984            const complete = () => {
4985              this._element.classList.remove(CLASS_NAME_SHOWING);
4986              EventHandler.trigger(this._element, EVENT_SHOWN);
4987              this._maybeScheduleHide();
4988            };
4989            this._element.classList.remove(CLASS_NAME_HIDE);
4990            reflow(this._element);
4991            this._element.classList.add(CLASS_NAME_SHOW, CLASS_NAME_SHOWING);
4992            this._queueCallback(complete, this._element, this._config.animation);
4993          }
4994          hide() {
4995            if (!this.isShown()) {
4996              return;
4997            }
4998            const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE);
4999            if (hideEvent.defaultPrevented) {
5000              return;
5001            }
5002            const complete = () => {
5003              this._element.classList.add(CLASS_NAME_HIDE);
5004              this._element.classList.remove(CLASS_NAME_SHOWING, CLASS_NAME_SHOW);
5005              EventHandler.trigger(this._element, EVENT_HIDDEN);
5006            };
5007            this._element.classList.add(CLASS_NAME_SHOWING);
5008            this._queueCallback(complete, this._element, this._config.animation);
5009          }
5010          dispose() {
5011            this._clearTimeout();
5012            if (this.isShown()) {
5013              this._element.classList.remove(CLASS_NAME_SHOW);
5014            }
5015            super.dispose();
5016          }
5017          isShown() {
5018            return this._element.classList.contains(CLASS_NAME_SHOW);
5019          }
5020          // Private
5021          _maybeScheduleHide() {
5022            if (!this._config.autohide) {
5023              return;
5024            }
5025            if (this._hasMouseInteraction || this._hasKeyboardInteraction) {
5026              return;
5027            }
5028            this._timeout = setTimeout(() => {
5029              this.hide();
5030            }, this._config.delay);
5031          }
5032          _onInteraction(event, isInteracting) {
5033            switch (event.type) {
5034              case "mouseover":
5035              case "mouseout": {
5036                this._hasMouseInteraction = isInteracting;
5037                break;
5038              }
5039              case "focusin":
5040              case "focusout": {
5041                this._hasKeyboardInteraction = isInteracting;
5042                break;
5043              }
5044            }
5045            if (isInteracting) {
5046              this._clearTimeout();
5047              return;
5048            }
5049            const nextElement = event.relatedTarget;
5050            if (this._element === nextElement || this._element.contains(nextElement)) {
5051              return;
5052            }
5053            this._maybeScheduleHide();
5054          }
5055          _setListeners() {
5056            EventHandler.on(this._element, EVENT_MOUSEOVER, (event) => this._onInteraction(event, true));
5057            EventHandler.on(this._element, EVENT_MOUSEOUT, (event) => this._onInteraction(event, false));
5058            EventHandler.on(this._element, EVENT_FOCUSIN, (event) => this._onInteraction(event, true));
5059            EventHandler.on(this._element, EVENT_FOCUSOUT, (event) => this._onInteraction(event, false));
5060          }
5061          _clearTimeout() {
5062            clearTimeout(this._timeout);
5063            this._timeout = null;
5064          }
5065          // Static
5066          static jQueryInterface(config3) {
5067            return this.each(function() {
5068              const data = Toast.getOrCreateInstance(this, config3);
5069              if (typeof config3 === "string") {
5070                if (typeof data[config3] === "undefined") {
5071                  throw new TypeError(`No method named "${config3}"`);
5072                }
5073                data[config3](this);
5074              }
5075            });
5076          }
5077        }
5078        enableDismissTrigger(Toast);
5079        defineJQueryPlugin(Toast);
5080        const index_umd = {
5081          Alert,
5082          Button,
5083          Carousel,
5084          Collapse,
5085          Dropdown,
5086          Modal,
5087          Offcanvas,
5088          Popover,
5089          ScrollSpy,
5090          Tab,
5091          Toast,
5092          Tooltip: Tooltip2
5093        };
5094        return index_umd;
5095      }));
5096    }
5097  });
5098
5099