https://qualityaging.com.au/site/DefaultSite/skins/QualityAgeing/js/index.js

139    Object.keys(state.elements).forEach(function(name) {
140      var element = state.elements[name];
141      var attributes = state.attributes[name] || {};
142      var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]);
143      var style = styleProperties.reduce(function(style2, property) {
144        style2[property] = "";
145        return style2;
146      }, {});
147      if (!isHTMLElement(element) || !getNodeName(element)) {
148        return;
149      }
150      Object.assign(element.style, style);
151      Object.keys(attributes).forEach(function(attribute) {
152        element.removeAttribute(attribute);
153      });
154    });
155  };
156}
157const applyStyles$1 = {
158  name: "applyStyles",
159  enabled: true,
160  phase: "write",
161  fn: applyStyles,
162  effect: effect$2,
163  requires: ["computeStyles"]
164};
165function getBasePlacement(placement) {
166  return placement.split("-")[0];
167}
168var max = Math.max;
169var min = Math.min;
170var round = Math.round;
171function getUAString() {
172  var uaData = navigator.userAgentData;
173  if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) {
174    return uaData.brands.map(function(item) {
175      return item.brand + "/" + item.version;
176    }).join(" ");
177  }
178  return navigator.userAgent;
179}
180function isLayoutViewport() {
181  return !/^((?!chrome|android).)*safari/i.test(getUAString());
182}
183function getBoundingClientRect(element, includeScale, isFixedStrategy) {
184  if (includeScale === void 0) {
185    includeScale = false;
186  }
187  if (isFixedStrategy === void 0) {
188    isFixedStrategy = false;
189  }
190  var clientRect = element.getBoundingClientRect();
191  var scaleX = 1;
192  var scaleY = 1;
193  if (includeScale && isHTMLElement(element)) {
194    scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
195    scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
196  }
197  var _ref = isElement$1(element) ? getWindow(element) : window, visualViewport = _ref.visualViewport;
198  var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
199  var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
200  var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
201  var width = clientRect.width / scaleX;
202  var height = clientRect.height / scaleY;
203  return {
204    width,
205    height,
206    top: y,
207    right: x + width,
208    bottom: y + height,
209    left: x,
210    x,
211    y
212  };
213}
214function getLayoutRect(element) {
215  var clientRect = getBoundingClientRect(element);
216  var width = element.offsetWidth;
217  var height = element.offsetHeight;
218  if (Math.abs(clientRect.width - width) <= 1) {
219    width = clientRect.width;
220  }
221  if (Math.abs(clientRect.height - height) <= 1) {
222    height = clientRect.height;
223  }
224  return {
225    x: element.offsetLeft,
226    y: element.offsetTop,
227    width,
228    height
229  };
230}
231function contains(parent, child) {
232  var rootNode = child.getRootNode && child.getRootNode();
233  if (parent.contains(child)) {
234    return true;
235  } else if (rootNode && isShadowRoot(rootNode)) {
236    var next = child;
237    do {
238      if (next && parent.isSameNode(next)) {
239        return true;
240      }
241      next = next.parentNode || next.host;
242    } while (next);
243  }
244  return false;
245}
246function getComputedStyle$1(element) {
247  return getWindow(element).getComputedStyle(element);
248}
249function isTableElement(element) {
250  return ["table", "td", "th"].indexOf(getNodeName(element)) >= 0;
251}
252function getDocumentElement(element) {
253  return ((isElement$1(element) ? element.ownerDocument : (
254    // $FlowFixMe[prop-missing]
255    element.document
256  )) || window.document).documentElement;
257}
258function getParentNode(element) {
259  if (getNodeName(element) === "html") {
260    return element;
261  }
262  return (
263    // this is a quicker (but less type safe) way to save quite some bytes from the bundle
264    // $FlowFixMe[incompatible-return]
265    // $FlowFixMe[prop-missing]
266    element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
267    element.parentNode || // DOM Element detected
268    (isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
269    // $FlowFixMe[incompatible-call]: HTMLElement is a Node
270    getDocumentElement(element)
271  );
272}
273function getTrueOffsetParent(element) {
274  if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
275  getComputedStyle$1(element).position === "fixed") {
276    return null;
277  }
278  return element.offsetParent;
279}
280function getContainingBlock(element) {
281  var isFirefox = /firefox/i.test(getUAString());
282  var isIE = /Trident/i.test(getUAString());
283  if (isIE && isHTMLElement(element)) {
284    var elementCss = getComputedStyle$1(element);
285    if (elementCss.position === "fixed") {
286      return null;
287    }
288  }
289  var currentNode = getParentNode(element);
290  if (isShadowRoot(currentNode)) {
291    currentNode = currentNode.host;
292  }
293  while (isHTMLElement(currentNode) && ["html", "body"].indexOf(getNodeName(currentNode)) < 0) {
294    var css = getComputedStyle$1(currentNode);
295    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") {
296      return currentNode;
297    } else {
298      currentNode = currentNode.parentNode;
299    }
300  }
301  return null;
302}
303function getOffsetParent(element) {
304  var window2 = getWindow(element);
305  var offsetParent = getTrueOffsetParent(element);
306  while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === "static") {
307    offsetParent = getTrueOffsetParent(offsetParent);
308  }
309  if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle$1(offsetParent).position === "static")) {
310    return window2;
311  }
312  return offsetParent || getContainingBlock(element) || window2;
313}
314function getMainAxisFromPlacement(placement) {
315  return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y";
316}
317function within(min$1, value, max$1) {
318  return max(min$1, min(value, max$1));
319}
320function withinMaxClamp(min2, value, max2) {
321  var v = within(min2, value, max2);
322  return v > max2 ? max2 : v;
323}
324function getFreshSideObject() {
325  return {
326    top: 0,
327    right: 0,
328    bottom: 0,
329    left: 0
330  };
331}
332function mergePaddingObject(paddingObject) {
333  return Object.assign({}, getFreshSideObject(), paddingObject);
334}
335function expandToHashMap(value, keys) {
336  return keys.reduce(function(hashMap, key) {
337    hashMap[key] = value;
338    return hashMap;
339  }, {});
340}
341var toPaddingObject = function toPaddingObject2(padding, state) {
342  padding = typeof padding === "function" ? padding(Object.assign({}, state.rects, {
343    placement: state.placement
344  })) : padding;
345  return mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
346};
347function arrow(_ref) {
348  var _state$modifiersData$;
349  var state = _ref.state, name = _ref.name, options = _ref.options;
350  var arrowElement = state.elements.arrow;
351  var popperOffsets2 = state.modifiersData.popperOffsets;
352  var basePlacement = getBasePlacement(state.placement);
353  var axis = getMainAxisFromPlacement(basePlacement);
354  var isVertical = [left, right].indexOf(basePlacement) >= 0;
355  var len = isVertical ? "height" : "width";
356  if (!arrowElement || !popperOffsets2) {
357    return;
358  }
359  var paddingObject = toPaddingObject(options.padding, state);
360  var arrowRect = getLayoutRect(arrowElement);
361  var minProp = axis === "y" ? top : left;
362  var maxProp = axis === "y" ? bottom : right;
363  var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets2[axis] - state.rects.popper[len];
364  var startDiff = popperOffsets2[axis] - state.rects.reference[axis];
365  var arrowOffsetParent = getOffsetParent(arrowElement);
366  var clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
367  var centerToReference = endDiff / 2 - startDiff / 2;
368  var min2 = paddingObject[minProp];
369  var max2 = clientSize - arrowRect[len] - paddingObject[maxProp];
370  var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
371  var offset2 = within(min2, center, max2);
372  var axisProp = axis;
373  state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset2, _state$modifiersData$.centerOffset = offset2 - center, _state$modifiersData$);
374}
375function effect$1(_ref2) {
376  var state = _ref2.state, options = _ref2.options;
377  var _options$element = options.element, arrowElement = _options$element === void 0 ? "[data-popper-arrow]" : _options$element;
378  if (arrowElement == null) {
379    return;
380  }
381  if (typeof arrowElement === "string") {
382    arrowElement = state.elements.popper.querySelector(arrowElement);
383    if (!arrowElement) {
384      return;
385    }
386  }
387  if (!contains(state.elements.popper, arrowElement)) {
388    return;
389  }
390  state.elements.arrow = arrowElement;
391}
392const arrow$1 = {
393  name: "arrow",
394  enabled: true,
395  phase: "main",
396  fn: arrow,
397  effect: effect$1,
398  requires: ["popperOffsets"],
399  requiresIfExists: ["preventOverflow"]
400};
401function getVariation(placement) {
402  return placement.split("-")[1];
403}
404var unsetSides = {
405  top: "auto",
406  right: "auto",
407  bottom: "auto",
408  left: "auto"
409};
410function roundOffsetsByDPR(_ref, win) {
411  var x = _ref.x, y = _ref.y;
412  var dpr = win.devicePixelRatio || 1;
413  return {
414    x: round(x * dpr) / dpr || 0,
415    y: round(y * dpr) / dpr || 0
416  };
417}
418function mapToStyles(_ref2) {
419  var _Object$assign2;
420  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;
421  var _offsets$x = offsets.x, x = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y = _offsets$y === void 0 ? 0 : _offsets$y;
422  var _ref3 = typeof roundOffsets === "function" ? roundOffsets({
423    x,
424    y
425  }) : {
426    x,
427    y
428  };
429  x = _ref3.x;
430  y = _ref3.y;
431  var hasX = offsets.hasOwnProperty("x");
432  var hasY = offsets.hasOwnProperty("y");
433  var sideX = left;
434  var sideY = top;
435  var win = window;
436  if (adaptive) {
437    var offsetParent = getOffsetParent(popper2);
438    var heightProp = "clientHeight";
439    var widthProp = "clientWidth";
440    if (offsetParent === getWindow(popper2)) {
441      offsetParent = getDocumentElement(popper2);
442      if (getComputedStyle$1(offsetParent).position !== "static" && position === "absolute") {
443        heightProp = "scrollHeight";
444        widthProp = "scrollWidth";
445      }
446    }
447    offsetParent = offsetParent;
448    if (placement === top || (placement === left || placement === right) && variation === end) {
449      sideY = bottom;
450      var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : (
451        // $FlowFixMe[prop-missing]
452        offsetParent[heightProp]
453      );
454      y -= offsetY - popperRect.height;
455      y *= gpuAcceleration ? 1 : -1;
456    }
457    if (placement === left || (placement === top || placement === bottom) && variation === end) {
458      sideX = right;
459      var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : (
460        // $FlowFixMe[prop-missing]
461        offsetParent[widthProp]
462      );
463      x -= offsetX - popperRect.width;
464      x *= gpuAcceleration ? 1 : -1;
465    }
466  }
467  var commonStyles = Object.assign({
468    position
469  }, adaptive && unsetSides);
470  var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
471    x,
472    y
473  }, getWindow(popper2)) : {
474    x,
475    y
476  };
477  x = _ref4.x;
478  y = _ref4.y;
479  if (gpuAcceleration) {
480    var _Object$assign;
481    return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? "0" : "", _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
482  }
483  return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : "", _Object$assign2[sideX] = hasX ? x + "px" : "", _Object$assign2.transform = "", _Object$assign2));
484}
485function computeStyles(_ref5) {
486  var state = _ref5.state, options = _ref5.options;
487  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;
488  var commonStyles = {
489    placement: getBasePlacement(state.placement),
490    variation: getVariation(state.placement),
491    popper: state.elements.popper,
492    popperRect: state.rects.popper,
493    gpuAcceleration,
494    isFixed: state.options.strategy === "fixed"
495  };
496  if (state.modifiersData.popperOffsets != null) {
497    state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
498      offsets: state.modifiersData.popperOffsets,
499      position: state.options.strategy,
500      adaptive,
501      roundOffsets
502    })));
503  }
504  if (state.modifiersData.arrow != null) {
505    state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
506      offsets: state.modifiersData.arrow,
507      position: "absolute",
508      adaptive: false,
509      roundOffsets
510    })));
511  }
512  state.attributes.popper = Object.assign({}, state.attributes.popper, {
513    "data-popper-placement": state.placement
514  });
515}
516const computeStyles$1 = {
517  name: "computeStyles",
518  enabled: true,
519  phase: "beforeWrite",
520  fn: computeStyles,
521  data: {}
522};
523var passive = {
524  passive: true
525};
526function effect(_ref) {
527  var state = _ref.state, instance = _ref.instance, options = _ref.options;
528  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;
529  var window2 = getWindow(state.elements.popper);
530  var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
531  if (scroll) {
532    scrollParents.forEach(function(scrollParent) {
533      scrollParent.addEventListener("scroll", instance.update, passive);
534    });
535  }
536  if (resize) {
537    window2.addEventListener("resize", instance.update, passive);
538  }
539  return function() {
540    if (scroll) {

601    height = visualViewport.height;
602    var layoutViewport = isLayoutViewport();
603    if (layoutViewport || !layoutViewport && strategy === "fixed") {
604      x = visualViewport.offsetLeft;
605      y = visualViewport.offsetTop;
606    }
607  }
608  return {
609    width,
610    height,
611    x: x + getWindowScrollBarX(element),
612    y
613  };
614}
615function getDocumentRect(element) {
616  var _element$ownerDocumen;
617  var html = getDocumentElement(element);
618  var winScroll = getWindowScroll(element);
619  var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
620  var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
621  var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
622  var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
623  var y = -winScroll.scrollTop;
624  if (getComputedStyle$1(body || html).direction === "rtl") {
625    x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
626  }
627  return {
628    width,
629    height,
630    x,
631    y
632  };
633}
634function isScrollParent(element) {
635  var _getComputedStyle = getComputedStyle$1(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY;
636  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
637}
638function getScrollParent(node) {
639  if (["html", "body", "#document"].indexOf(getNodeName(node)) >= 0) {
640    return node.ownerDocument.body;
641  }
642  if (isHTMLElement(node) && isScrollParent(node)) {
643    return node;
644  }
645  return getScrollParent(getParentNode(node));
646}
647function listScrollParents(element, list) {
648  var _element$ownerDocumen;
649  if (list === void 0) {
650    list = [];
651  }
652  var scrollParent = getScrollParent(element);
653  var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
654  var win = getWindow(scrollParent);
655  var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
656  var updatedList = list.concat(target);
657  return isBody ? updatedList : (
658    // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
659    updatedList.concat(listScrollParents(getParentNode(target)))
660  );
661}
662function rectToClientRect(rect) {
663  return Object.assign({}, rect, {
664    left: rect.x,
665    top: rect.y,
666    right: rect.x + rect.width,
667    bottom: rect.y + rect.height
668  });
669}
670function getInnerBoundingClientRect(element, strategy) {
671  var rect = getBoundingClientRect(element, false, strategy === "fixed");
672  rect.top = rect.top + element.clientTop;
673  rect.left = rect.left + element.clientLeft;
674  rect.bottom = rect.top + element.clientHeight;
675  rect.right = rect.left + element.clientWidth;
676  rect.width = element.clientWidth;
677  rect.height = element.clientHeight;
678  rect.x = rect.left;
679  rect.y = rect.top;
680  return rect;
681}
682function getClientRectFromMixedType(element, clippingParent, strategy) {
683  return clippingParent === viewport ? rectToClientRect(getViewportRect(element, strategy)) : isElement$1(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
684}
685function getClippingParents(element) {
686  var clippingParents2 = listScrollParents(getParentNode(element));
687  var canEscapeClipping = ["absolute", "fixed"].indexOf(getComputedStyle$1(element).position) >= 0;
688  var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
689  if (!isElement$1(clipperElement)) {
690    return [];
691  }
692  return clippingParents2.filter(function(clippingParent) {
693    return isElement$1(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== "body";
694  });
695}
696function getClippingRect(element, boundary, rootBoundary, strategy) {
697  var mainClippingParents = boundary === "clippingParents" ? getClippingParents(element) : [].concat(boundary);
698  var clippingParents2 = [].concat(mainClippingParents, [rootBoundary]);
699  var firstClippingParent = clippingParents2[0];
700  var clippingRect = clippingParents2.reduce(function(accRect, clippingParent) {
701    var rect = getClientRectFromMixedType(element, clippingParent, strategy);
702    accRect.top = max(rect.top, accRect.top);
703    accRect.right = min(rect.right, accRect.right);
704    accRect.bottom = min(rect.bottom, accRect.bottom);
705    accRect.left = max(rect.left, accRect.left);
706    return accRect;
707  }, getClientRectFromMixedType(element, firstClippingParent, strategy));
708  clippingRect.width = clippingRect.right - clippingRect.left;
709  clippingRect.height = clippingRect.bottom - clippingRect.top;
710  clippingRect.x = clippingRect.left;
711  clippingRect.y = clippingRect.top;
712  return clippingRect;
713}
714function computeOffsets(_ref) {
715  var reference2 = _ref.reference, element = _ref.element, placement = _ref.placement;
716  var basePlacement = placement ? getBasePlacement(placement) : null;
717  var variation = placement ? getVariation(placement) : null;
718  var commonX = reference2.x + reference2.width / 2 - element.width / 2;
719  var commonY = reference2.y + reference2.height / 2 - element.height / 2;
720  var offsets;
721  switch (basePlacement) {
722    case top:
723      offsets = {
724        x: commonX,
725        y: reference2.y - element.height
726      };
727      break;
728    case bottom:
729      offsets = {
730        x: commonX,
731        y: reference2.y + reference2.height
732      };
733      break;
734    case right:
735      offsets = {
736        x: reference2.x + reference2.width,
737        y: commonY
738      };
739      break;
740    case left:
741      offsets = {
742        x: reference2.x - element.width,
743        y: commonY
744      };
745      break;
746    default:
747      offsets = {
748        x: reference2.x,
749        y: reference2.y
750      };
751  }
752  var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
753  if (mainAxis != null) {
754    var len = mainAxis === "y" ? "height" : "width";
755    switch (variation) {
756      case start:
757        offsets[mainAxis] = offsets[mainAxis] - (reference2[len] / 2 - element[len] / 2);
758        break;
759      case end:
760        offsets[mainAxis] = offsets[mainAxis] + (reference2[len] / 2 - element[len] / 2);
761        break;
762    }
763  }
764  return offsets;
765}
766function detectOverflow(state, options) {
767  if (options === void 0) {
768    options = {};
769  }
770  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;

775.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy);
776  var referenceClientRect = getBoundingClientRect(state.elements.reference);
777  var popperOffsets2 = computeOffsets({
778    reference: referenceClientRect,
779    element: popperRect,
780    strategy: "absolute",
781    placement
782  });
783  var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets2));
784  var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect;
785  var overflowOffsets = {
786    top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
787    bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
788    left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
789    right: elementClientRect.right - clippingClientRect.right + paddingObject.right
790  };
791  var offsetData = state.modifiersData.offset;
792  if (elementContext === popper && offsetData) {
793    var offset2 = offsetData[placement];
794    Object.keys(overflowOffsets).forEach(function(key) {
795      var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
796      var axis = [top, bottom].indexOf(key) >= 0 ? "y" : "x";
797      overflowOffsets[key] += offset2[axis] * multiply;
798    });
799  }
800  return overflowOffsets;
801}
802function computeAutoPlacement(state, options) {
803  if (options === void 0) {
804    options = {};
805  }
806  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;
807  var variation = getVariation(placement);
808  var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function(placement2) {
809    return getVariation(placement2) === variation;
810  }) : basePlacements;
811  var allowedPlacements = placements$1.filter(function(placement2) {
812    return allowedAutoPlacements.indexOf(placement2) >= 0;
813  });
814  if (allowedPlacements.length === 0) {
815    allowedPlacements = placements$1;
816  }
817  var overflows = allowedPlacements.reduce(function(acc, placement2) {
818    acc[placement2] = detectOverflow(state, {
819      placement: placement2,
820      boundary,
821      rootBoundary,
822      padding
823    })[getBasePlacement(placement2)];
824    return acc;
825  }, {});
826  return Object.keys(overflows).sort(function(a, b) {
827    return overflows[a] - overflows[b];
828  });
829}
830function getExpandedFallbackPlacements(placement) {
831  if (getBasePlacement(placement) === auto) {
832    return [];
833  }
834  var oppositePlacement = getOppositePlacement(placement);
835  return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
836}
837function flip(_ref) {
838  var state = _ref.state, options = _ref.options, name = _ref.name;
839  if (state.modifiersData[name]._skip) {
840    return;
841  }
842  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;
843  var preferredPlacement = state.options.placement;
844  var basePlacement = getBasePlacement(preferredPlacement);
845  var isBasePlacement = basePlacement === preferredPlacement;
846  var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
847  var placements2 = [preferredPlacement].concat(fallbackPlacements).reduce(function(acc, placement2) {
848    return acc.concat(getBasePlacement(placement2) === auto ? computeAutoPlacement(state, {
849      placement: placement2,
850      boundary,
851      rootBoundary,
852      padding,
853      flipVariations,
854      allowedAutoPlacements
855    }) : placement2);
856  }, []);
857  var referenceRect = state.rects.reference;
858  var popperRect = state.rects.popper;
859  var checksMap = /* @__PURE__ */ new Map();
860  var makeFallbackChecks = true;
861  var firstFittingPlacement = placements2[0];
862  for (var i = 0; i < placements2.length; i++) {
863    var placement = placements2[i];
864    var _basePlacement = getBasePlacement(placement);
865    var isStartVariation = getVariation(placement) === start;
866    var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;
867    var len = isVertical ? "width" : "height";
868    var overflow = detectOverflow(state, {
869      placement,
870      boundary,
871      rootBoundary,
872      altBoundary,
873      padding
874    });
875    var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
876    if (referenceRect[len] > popperRect[len]) {
877      mainVariationSide = getOppositePlacement(mainVariationSide);
878    }
879    var altVariationSide = getOppositePlacement(mainVariationSide);
880    var checks = [];
881    if (checkMainAxis) {
882      checks.push(overflow[_basePlacement] <= 0);
883    }
884    if (checkAltAxis) {
885      checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
886    }
887    if (checks.every(function(check) {
888      return check;
889    })) {
890      firstFittingPlacement = placement;
891      makeFallbackChecks = false;
892      break;
893    }
894    checksMap.set(placement, checks);
895  }
896  if (makeFallbackChecks) {
897    var numberOfChecks = flipVariations ? 3 : 1;
898    var _loop = function _loop2(_i2) {
899      var fittingPlacement = placements2.find(function(placement2) {
900        var checks2 = checksMap.get(placement2);
901        if (checks2) {
902          return checks2.slice(0, _i2).every(function(check) {
903            return check;
904          });
905        }
906      });
907      if (fittingPlacement) {
908        firstFittingPlacement = fittingPlacement;
909        return "break";
910      }
911    };
912    for (var _i = numberOfChecks; _i > 0; _i--) {
913      var _ret = _loop(_i);
914      if (_ret === "break")
915        break;
916    }
917  }
918  if (state.placement !== firstFittingPlacement) {
919    state.modifiersData[name]._skip = true;
920    state.placement = firstFittingPlacement;
921    state.reset = true;
922  }
923}
924const flip$1 = {
925  name: "flip",
926  enabled: true,
927  phase: "main",
928  fn: flip,
929  requiresIfExists: ["offset"],
930  data: {
931    _skip: false
932  }
933};
934function getSideOffsets(overflow, rect, preventedOffsets) {
935  if (preventedOffsets === void 0) {
936    preventedOffsets = {
937      x: 0,
938      y: 0
939    };
940  }
941  return {
942    top: overflow.top - rect.height - preventedOffsets.y,
943    right: overflow.right - rect.width + preventedOffsets.x,
944    bottom: overflow.bottom - rect.height + preventedOffsets.y,
945    left: overflow.left - rect.width - preventedOffsets.x
946  };
947}
948function isAnySideFullyClipped(overflow) {
949  return [top, right, bottom, left].some(function(side) {
950    return overflow[side] >= 0;
951  });
952}
953function hide(_ref) {
954  var state = _ref.state, name = _ref.name;
955  var referenceRect = state.rects.reference;
956  var popperRect = state.rects.popper;
957  var preventedOffsets = state.modifiersData.preventOverflow;
958  var referenceOverflow = detectOverflow(state, {
959    elementContext: "reference"
960  });
961  var popperAltOverflow = detectOverflow(state, {
962    altBoundary: true
963  });
964  var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
965  var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
966  var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
967  var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
968  state.modifiersData[name] = {
969    referenceClippingOffsets,
970    popperEscapeOffsets,
971    isReferenceHidden,
972    hasPopperEscaped
973  };
974  state.attributes.popper = Object.assign({}, state.attributes.popper, {
975    "data-popper-reference-hidden": isReferenceHidden,
976    "data-popper-escaped": hasPopperEscaped
977  });
978}
979const hide$1 = {
980  name: "hide",
981  enabled: true,
982  phase: "main",
983  requiresIfExists: ["preventOverflow"],
984  fn: hide
985};
986function distanceAndSkiddingToXY(placement, rects, offset2) {
987  var basePlacement = getBasePlacement(placement);
988  var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
989  var _ref = typeof offset2 === "function" ? offset2(Object.assign({}, rects, {
990    placement
991  })) : offset2, skidding = _ref[0], distance = _ref[1];
992  skidding = skidding || 0;
993  distance = (distance || 0) * invertDistance;
994  return [left, right].indexOf(basePlacement) >= 0 ? {
995    x: distance,
996    y: skidding
997  } : {
998    x: skidding,
999    y: distance
1000  };
1001}
1002function offset(_ref2) {
1003  var state = _ref2.state, options = _ref2.options, name = _ref2.name;
1004  var _options$offset = options.offset, offset2 = _options$offset === void 0 ? [0, 0] : _options$offset;
1005  var data = placements.reduce(function(acc, placement) {
1006    acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset2);
1007    return acc;
1008  }, {});
1009  var _data$state$placement = data[state.placement], x = _data$state$placement.x, y = _data$state$placement.y;
1010  if (state.modifiersData.popperOffsets != null) {
1011    state.modifiersData.popperOffsets.x += x;
1012    state.modifiersData.popperOffsets.y += y;
1013  }
1014  state.modifiersData[name] = data;
1015}
1016const offset$1 = {
1017  name: "offset",
1018  enabled: true,
1019  phase: "main",
1020  requires: ["popperOffsets"],
1021  fn: offset
1022};
1023function popperOffsets(_ref) {
1024  var state = _ref.state, name = _ref.name;
1025  state.modifiersData[name] = computeOffsets({
1026    reference: state.rects.reference,
1027    element: state.rects.popper,
1028    strategy: "absolute",
1029    placement: state.placement
1030  });
1031}
1032const popperOffsets$1 = {
1033  name: "popperOffsets",
1034  enabled: true,
1035  phase: "read",
1036  fn: popperOffsets,
1037  data: {}
1038};
1039function getAltAxis(axis) {
1040  return axis === "x" ? "y" : "x";
1041}
1042function preventOverflow(_ref) {
1043  var state = _ref.state, options = _ref.options, name = _ref.name;
1044  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;
1045  var overflow = detectOverflow(state, {
1046    boundary,
1047    rootBoundary,
1048    padding,
1049    altBoundary
1050  });
1051  var basePlacement = getBasePlacement(state.placement);
1052  var variation = getVariation(state.placement);
1053  var isBasePlacement = !variation;
1054  var mainAxis = getMainAxisFromPlacement(basePlacement);
1055  var altAxis = getAltAxis(mainAxis);
1056  var popperOffsets2 = state.modifiersData.popperOffsets;
1057  var referenceRect = state.rects.reference;
1058  var popperRect = state.rects.popper;
1059  var tetherOffsetValue = typeof tetherOffset === "function" ? tetherOffset(Object.assign({}, state.rects, {
1060    placement: state.placement
1061  })) : tetherOffset;
1062  var normalizedTetherOffsetValue = typeof tetherOffsetValue === "number" ? {
1063    mainAxis: tetherOffsetValue,
1064    altAxis: tetherOffsetValue
1065  } : Object.assign({
1066    mainAxis: 0,
1067    altAxis: 0
1068  }, tetherOffsetValue);
1069  var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
1070  var data = {
1071    x: 0,
1072    y: 0
1073  };
1074  if (!popperOffsets2) {
1075    return;
1076  }
1077  if (checkMainAxis) {
1078    var _offsetModifierState$;
1079    var mainSide = mainAxis === "y" ? top : left;
1080    var altSide = mainAxis === "y" ? bottom : right;
1081    var len = mainAxis === "y" ? "height" : "width";
1082    var offset2 = popperOffsets2[mainAxis];
1083    var min$1 = offset2 + overflow[mainSide];
1084    var max$1 = offset2 - overflow[altSide];
1085    var additive = tether ? -popperRect[len] / 2 : 0;
1086    var minLen = variation === start ? referenceRect[len] : popperRect[len];
1087    var maxLen = variation === start ? -popperRect[len] : -referenceRect[len];
1088    var arrowElement = state.elements.arrow;
1089    var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
1090      width: 0,
1091      height: 0
1092    };
1093    var arrowPaddingObject = state.modifiersData["arrow#persistent"] ? state.modifiersData["arrow#persistent"].padding : getFreshSideObject();
1094    var arrowPaddingMin = arrowPaddingObject[mainSide];
1095    var arrowPaddingMax = arrowPaddingObject[altSide];
1096    var arrowLen = within(0, referenceRect[len], arrowRect[len]);
1097    var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
1098    var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
1099    var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
1100    var clientOffset = arrowOffsetParent ? mainAxis === "y" ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
1101    var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
1102    var tetherMin = offset2 + minOffset - offsetModifierValue - clientOffset;
1103    var tetherMax = offset2 + maxOffset - offsetModifierValue;
1104    var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset2, tether ? max(max$1, tetherMax) : max$1);
1105    popperOffsets2[mainAxis] = preventedOffset;
1106    data[mainAxis] = preventedOffset - offset2;
1107  }
1108  if (checkAltAxis) {
1109    var _offsetModifierState$2;
1110    var _mainSide = mainAxis === "x" ? top : left;
1111    var _altSide = mainAxis === "x" ? bottom : right;
1112    var _offset = popperOffsets2[altAxis];
1113    var _len = altAxis === "y" ? "height" : "width";
1114    var _min = _offset + overflow[_mainSide];
1115    var _max = _offset - overflow[_altSide];
1116    var isOriginSide = [top, left].indexOf(basePlacement) !== -1;
1117    var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
1118    var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
1119    var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
1120    var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
1121    popperOffsets2[altAxis] = _preventedOffset;
1122    data[altAxis] = _preventedOffset - _offset;
1123  }
1124  state.modifiersData[name] = data;
1125}
1126const preventOverflow$1 = {
1127  name: "preventOverflow",
1128  enabled: true,
1129  phase: "main",
1130  fn: preventOverflow,
1131  requiresIfExists: ["offset"]
1132};
1133function getHTMLElementScroll(element

1133) {
1134  return {
1135    scrollLeft: element.scrollLeft,
1136    scrollTop: element.scrollTop
1137  };
1138}
1139function getNodeScroll(node) {
1140  if (node === getWindow(node) || !isHTMLElement(node)) {
1141    return getWindowScroll(node);
1142  } else {
1143    return getHTMLElementScroll(node);
1144  }
1145}
1146function isElementScaled(element) {
1147  var rect = element.getBoundingClientRect();
1148  var scaleX = round(rect.width) / element.offsetWidth || 1;
1149  var scaleY = round(rect.height) / element.offsetHeight || 1;
1150  return scaleX !== 1 || scaleY !== 1;
1151}
1152function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
1153  if (isFixed === void 0) {
1154    isFixed = false;
1155  }
1156  var isOffsetParentAnElement = isHTMLElement(offsetParent);
1157  var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
1158  var documentElement = getDocumentElement(offsetParent);
1159  var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed);
1160  var scroll = {
1161    scrollLeft: 0,
1162    scrollTop: 0
1163  };
1164  var offsets = {
1165    x: 0,
1166    y: 0
1167  };
1168  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
1169    if (getNodeName(offsetParent) !== "body" || // https://github.com/popperjs/popper-core/issues/1078
1170    isScrollParent(documentElement)) {
1171      scroll = getNodeScroll(offsetParent);
1172    }
1173    if (isHTMLElement(offsetParent)) {
1174      offsets = getBoundingClientRect(offsetParent, true);
1175      offsets.x += offsetParent.clientLeft;
1176      offsets.y += offsetParent.clientTop;
1177    } else if (documentElement) {
1178      offsets.x = getWindowScrollBarX(documentElement);
1179    }
1180  }
1181  return {
1182    x: rect.left + scroll.scrollLeft - offsets.x,
1183    y: rect.top + scroll.scrollTop - offsets.y,
1184    width: rect.width,
1185    height: rect.height
1186  };
1187}
1188function order(modifiers) {
1189  var map = /* @__PURE__ */ new Map();
1190  var visited = /* @__PURE__ */ new Set();
1191  var result = [];

1192  modifiers.forEach(function(modifier) {
1193    map.set(modifier.name, modifier);
1194  });
1195  function sort(modifier) {
1196    visited.add(modifier.name);
1197    var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
1198    requires.forEach(function(dep) {
1199      if (!visited.has(dep)) {
1200        var depModifier = map.get(dep);
1201        if (depModifier) {
1202          sort(depModifier);
1203        }
1204      }
1205    });
1206    result.push(modifier);
1207  }
1208  modifiers.forEach(function(modifier) {
1209    if (!visited.has(modifier.name)) {
1210      sort(modifier);
1211    }
1212  });
1213  return result;
1214}
1215function orderModifiers(modifiers) {
1216  var orderedModifiers = order(modifiers);
1217  return modifierPhases.reduce(function(acc, phase) {
1218    return acc.concat(orderedModifiers.filter(function(modifier) {
1219      return modifier.phase === phase;
1220    }));
1221  }, []);
1222}
1223function debounce(fn2) {
1224  var pending;
1225  return function() {
1226    if (!pending) {
1227      pending = new Promise(function(resolve) {
1228        Promise.resolve().then(function() {
1229          pending = void 0;
1230          resolve(fn2());
1231        });
1232      });
1233    }
1234    return pending;
1235  };
1236}
1237function mergeByName(modifiers) {
1238  var merged = modifiers.reduce(function(merged2, current) {
1239    var existing = merged2[current.name];
1240    merged2[current.name] = existing ? Object.assign({}, existing, current, {
1241      options: Object.assign({}, existing.options, current.options),
1242      data: Object.assign({}, existing.data, current.data)
1243    }) : current;
1244    return merged2;
1245  }, {});
1246  return Object.keys(merged).map(function(key) {
1247    return merged[key];
1248  });
1249}
1250var DEFAULT_OPTIONS = {
1251  placement: "bottom",
1252  modifiers: [],
1253  strategy: "absolute"
1254};
1255function areValidElements() {
1256  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
1257    args[_key] = arguments[_key];
1258  }
1259  return !args.some(function(element) {
1260    return !(element && typeof element.getBoundingClientRect === "function");
1261  });
1262}
1263function popperGenerator(generatorOptions) {
1264  if (generatorOptions === void 0) {
1265    generatorOptions = {};
1266  }
1267  var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers2 = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
1268  return function createPopper2(reference2, popper2, options) {
1269    if (options === void 0) {
1270      options = defaultOptions;
1271    }
1272    var state = {
1273      placement: "bottom",
1274      orderedModifiers: [],
1275      options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
1276      modifiersData: {},
1277      elements: {
1278        reference: reference2,
1279        popper: popper2
1280      },
1281      attributes: {},
1282      styles: {}
1283    };
1284    var effectCleanupFns = [];
1285    var isDestroyed = false;
1286    var instance = {
1287      state,
1288      setOptions: function setOptions(setOptionsAction) {
1289        var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
1290        cleanupModifierEffects();
1291        state.options = Object.assign({}, defaultOptions, state.options, options2);
1292        state.scrollParents = {
1293          reference: isElement$1(reference2) ? listScrollParents(reference2) : reference2.contextElement ? listScrollParents(reference2.contextElement) : [],
1294          popper: listScrollParents(popper2)
1295        };
1296        var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers2, state.options.modifiers)));
1297        state.orderedModifiers = orderedModifiers.filter(function(m) {
1298          return m.enabled;
1299        });
1300        runModifierEffects();
1301        return instance.update();
1302      },
1303      // Sync update – it will always be executed, even if not necessary. This
1304      // is useful for low frequency updates where sync behavior simplifies the
1305      // logic.
1306      // For high frequency updates (e.g. `resize` and `scroll` events), always
1307      // prefer the async Popper#update method

1308      forceUpdate: function forceUpdate() {
1309        if (isDestroyed) {
1310          return;
1311        }
1312        var _state$elements = state.elements, reference3 = _state$elements.reference, popper3 = _state$elements.popper;
1313        if (!areValidElements(reference3, popper3)) {
1314          return;
1315        }
1316        state.rects = {
1317          reference: getCompositeRect(reference3, getOffsetParent(popper3), state.options.strategy === "fixed"),
1318          popper: getLayoutRect(popper3)
1319        };
1320        state.reset = false;
1321        state.placement = state.options.placement;
1322        state.orderedModifiers.forEach(function(modifier) {
1323          return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
1324        });
1325        for (var index = 0; index < state.orderedModifiers.length; index++) {
1326          if (state.reset === true) {
1327            state.reset = false;
1328            index = -1;
1329            continue;
1330          }
1331          var _state$orderedModifie = state.orderedModifiers[index], fn2 = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name;
1332          if (typeof fn2 === "function") {
1333            state = fn2({
1334              state,
1335              options: _options,
1336              name,
1337              instance
1338            }) || state;
1339          }
1340        }
1341      },
1342      // Async and optimistically optimized update – it will not be executed if
1343      // not necessary (debounced to run at most once-per-tick)
1344      update: debounce(function() {
1345        return new Promise(function(resolve) {
1346          instance.forceUpdate();
1347          resolve(state);
1348        });
1349      }),
1350      destroy: function destroy() {
1351        cleanupModifierEffects();
1352        isDestroyed = true;
1353      }
1354    };
1355    if (!areValidElements(reference2, popper2)) {
1356      return instance;
1357    }
1358    instance.setOptions(options).then(function(state2) {
1359      if (!isDestroyed && options.onFirstUpdate) {
1360        options.onFirstUpdate(state2);
1361      }
1362    });
1363    function runModifierEffects() {
1364      state.orderedModifiers.forEach(function(_ref) {
1365        var name = _ref.name, _ref$options = _ref.options, options2 = _ref$options === void 0 ? {} : _ref$options, effect2 = _ref.effect;
1366        if (typeof effect2 === "function") {
1367          var cleanupFn = effect2({
1368            state,
1369            name,
1370            instance,
1371            options: options2
1372          });
1373          var noopFn = function noopFn2() {
1374          };
1375          effectCleanupFns.push(cleanupFn || noopFn);
1376        }
1377      });
1378    }
1379    function cleanupModifierEffects() {
1380      effectCleanupFns.forEach(function(fn2) {
1381        return fn2();
1382      });
1383      effectCleanupFns = [];
1384    }
1385    return instance;
1386  };
1387}
1388var createPopper$2 = /* @__PURE__ */ popperGenerator();
1389var defaultModifiers$1 = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1];
1390var createPopper$1 = /* @__PURE__ */ popperGenerator({
1391  defaultModifiers: defaultModifiers$1
1392});
1393var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1];
1394var createPopper = /* @__PURE__ */ popperGenerator({
1395  defaultModifiers
1396});
1397const Popper = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
1398  __proto__: null,
1399  afterMain,
1400  afterRead,
1401  afterWrite,
1402  applyStyles: applyStyles$1,
1403  arrow: arrow$1,
1404  auto,
1405  basePlacements,
1406  beforeMain,
1407  beforeRead,
1408  beforeWrite,
1409  bottom,
1410  clippingParents,
1411  computeStyles: computeStyles$1,
1412  createPopper,
1413  createPopperBase: createPopper$2,
1414  createPopperLite: createPopper$1,
1415  detectOverflow,
1416  end,
1417  eventListeners,
1418  flip: flip$1,
1419  hide: hide$1,
1420  left,
1421  main,
1422  modifierPhases,
1423  offset: offset$1,
1424  placements,
1425  popper,
1426  popperGenerator,
1427  popperOffsets: popperOffsets$1,
1428  preventOverflow: preventOverflow$1,
1429  read,
1430  reference,
1431  right,
1432  start,
1433  top,
1434  variationPlacements,
1435  viewport,
1436  write
1437}, Symbol.toStringTag, { value: "Module" }));
1438/*!
1439  * Bootstrap v5.3.1 (https://getbootstrap.com/)
1440  * Copyright 2011-2023 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
1441  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1442  */
1443const elementMap = /* @__PURE__ */ new Map();
1444const Data = {
1445  set(element, key, instance) {
1446    if (!elementMap.has(element)) {
1447      elementMap.set(element, /* @__PURE__ */ new Map());
1448    }
1449    const instanceMap = elementMap.get(element);
1450    if (!instanceMap.has(key) && instanceMap.size !== 0) {
1451      console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);
1452      return;
1453    }
1454    instanceMap.set(key, instance);
1455  },
1456  get(element, key) {
1457    if (elementMap.has(element)) {
1458      return elementMap.get(element).get(key) || null;
1459    }
1460    return null;
1461  },
1462  remove(element, key) {
1463    if (!elementMap.has(element)) {
1464      return;
1465    }
1466    const instanceMap = elementMap.get(element);
1467    instanceMap.delete(key);
1468    if (instanceMap.size === 0) {
1469      elementMap.delete(element);
1470    }
1471  }
1472};
1473const MAX_UID = 1e6;
1474const MILLISECONDS_MULTIPLIER = 1e3;
1475const TRANSITION_END = "transitionend";
1476const parseSelector = (selector) => {
1477  if (selector && window.CSS && window.CSS.escape) {
1478    selector = selector.replace(/#([^\s"#']+)/g, (match, id) => `#${CSS.escape(id)}`);
1479  }
1480  return selector;
1481};
1482const toType = (object) => {
1483  if (object === null || object === void 0) {
1484    return `${object}`;
1485  }
1486  return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase();
1487};
1488const getUID = (prefix) => {
1489  do {
1490    prefix += Math.floor(Math.random() * MAX_UID);
1491  } while (document.getElementById(prefix));
1492  return prefix;
1493};
1494const getTransitionDurationFromElement = (element) => {
1495  if (!element) {
1496    return 0;
1497  }
1498  let {
1499    transitionDuration,
1500    transitionDelay
1501  } = window.getComputedStyle(element);
1502  const floatTransitionDuration = Number.parseFloat(transitionDuration);
1503  const floatTransitionDelay = Number.parseFloat(transitionDelay);
1504  if (!floatTransitionDuration && !floatTransitionDelay) {
1505    return 0;
1506  }
1507  transitionDuration = transitionDuration.split(",")[0];
1508  transitionDelay = transitionDelay.split(",")[0];
1509  return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
1510};
1511const triggerTransitionEnd = (element) => {
1512  element.dispatchEvent(new Event(TRANSITION_END));
1513};
1514const isElement = (object) => {
1515  if (!object || typeof object !== "object") {
1516    return false;
1517  }
1518  if (typeof object.jquery !== "undefined") {
1519    object = object[0];
1520  }
1521  return typeof object.nodeType !== "undefined";
1522};
1523const getElement = (object) => {
1524  if (isElement(object)) {
1525    return object.jquery ? object[0] : object;
1526  }
1527  if (typeof object === "string" && object.length > 0) {
1528    return document.querySelector(parseSelector(object));
1529  }
1530  return null;
1531};
1532const isVisible = (element) => {
1533  if (!isElement(element) || element.getClientRects().length === 0) {
1534    return false;
1535  }
1536  const elementIsVisible = getComputedStyle(element).getPropertyValue("visibility") === "visible";
1537  const closedDetails = element.closest("details:not([open])");
1538  if (!closedDetails) {
1539    return elementIsVisible;
1540  }
1541  if (closedDetails !== element) {
1542    const summary = element.closest("summary");
1543    if (summary && summary.parentNode !== closedDetails) {
1544      return false;
1545    }
1546    if (summary === null) {
1547      return false;
1548    }
1549  }
1550  return elementIsVisible;
1551};
1552const isDisabled = (element) => {
1553  if (!element || element.nodeType !== Node.ELEMENT_NODE) {
1554    return true;
1555  }
1556  if (element.classList.contains("disabled")) {
1557    return true;
1558  }
1559  if (typeof element.disabled !== "undefined") {
1560    return element.disabled;
1561  }
1562  return element.hasAttribute("disabled") && element.getAttribute("disabled") !== "false";
1563};
1564const findShadowRoot = (element) => {
1565  if (!document.documentElement.attachShadow) {
1566    return null;
1567  }
1568  if (typeof element.getRootNode === "function") {
1569    const root = element.getRootNode();
1570    return root instanceof ShadowRoot ? root : null;
1571  }
1572  if (element instanceof ShadowRoot) {
1573    return element;
1574  }
1575  if (!element.parentNode) {
1576    return null;
1577  }
1578  return findShadowRoot(element.parentNode);
1579};
1580const noop = () => {
1581};
1582const reflow = (element) => {
1583  element.offsetHeight;
1584};
1585const getjQuery = () => {
1586  if (window.jQuery && !document.body.hasAttribute("data-bs-no-jquery")) {
1587    return window.jQuery;
1588  }
1589  return null;
1590};
1591const DOMContentLoadedCallbacks = [];
1592const onDOMContentLoaded = (callback) => {
1593  if (document.readyState === "loading") {
1594    if (!DOMContentLoadedCallbacks.length) {
1595      document.addEventListener("DOMContentLoaded", () => {
1596        for (const callback2 of DOMContentLoadedCallbacks) {
1597          callback2();
1598        }
1599      });
1600    }
1601    DOMContentLoadedCallbacks.push(callback);
1602  } else {
1603    callback();
1604  }
1605};
1606const isRTL = () => document.documentElement.dir === "rtl";
1607const defineJQueryPlugin = (plugin) => {
1608  onDOMContentLoaded(() => {
1609    const $ = getjQuery();
1610    if ($) {
1611      const name = plugin.NAME;
1612      const JQUERY_NO_CONFLICT = $.fn[name];
1613      $.fn[name] = plugin.jQueryInterface;
1614      $.fn[name].Constructor = plugin;
1615      $.fn[name].noConflict = () => {
1616        $.fn[name] = JQUERY_NO_CONFLICT;
1617        return plugin.jQueryInterface;
1618      };
1619    }
1620  });
1621};
1622const execute = (possibleCallback, args = [], defaultValue = possibleCallback) => {
1623  return typeof possibleCallback === "function" ? possibleCallback(...args) : defaultValue;
1624};
1625const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
1626  if (!waitForTransition) {
1627    execute(callback);
1628    return;
1629  }
1630  const durationPadding = 5;
1631  const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
1632  let called = false;
1633  const handler = ({
1634    target
1635  }) => {
1636    if (target !== transitionElement) {
1637      return;
1638    }
1639    called = true;
1640    transitionElement.removeEventListener(TRANSITION_END, handler);
1641    execute(callback);
1642  };
1643  transitionElement.addEventListener(TRANSITION_END, handler);
1644  setTimeout(() => {
1645    if (!called) {
1646      triggerTransitionEnd(transitionElement);
1647    }
1648  }, emulatedDuration);
1649};
1650const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
1651  const listLength = list.length;
1652  let index = list.indexOf(activeElement);
1653  if (index === -1) {
1654    return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];
1655  }
1656  index += shouldGetNext ? 1 : -1;
1657  if (isCycleAllowed) {
1658    index = (index + listLength) % listLength;
1659  }
1660  return list[Math.max(0, Math.min(index, listLength - 1))];
1661};
1662const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
1663const stripNameRegex = /\..*/;
1664const stripUidRegex = /::\d+$/;
1665const eventRegistry = {};
1666let uidEvent = 1;
1667const customEvents = {
1668  mouseenter: "mouseover",
1669  mouseleave: "mouseout"
1670};
1671const 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"]);
1672function makeEventUid(element, uid) {
1673  return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
1674}
1675function getElementEvents(element) {
1676  const uid = makeEventUid(element);
1677  element.uidEvent = uid;
1678  eventRegistry[uid] = eventRegistry[uid] || {};
1679  return eventRegistry[uid];
1680}
1681function bootstrapHandler(element, fn2) {
1682  return function handler(event) {
1683    hydrateObj(event, {
1684      delegateTarget: element
1685    });
1686    if (handler.oneOff) {
1687      EventHandler.off(element, event.type, fn2);
1688    }
1689    return fn2.apply(element, [event]);
1690  };
1691}
1692function bootstrapDelegationHandler(element, selector, fn2) {
1693  return function handler(event) {
1694    const domElements = element.querySelectorAll(selector);
1695    for (let {
1696      target
1697    } = event; target && target !== this; target = target.parentNode) {
1698      for (const domElement of domElements) {
1699        if (domElement !== target) {
1700          continue;
1701        }
1702        hydrateObj(event, {
1703          delegateTarget: target
1704        });
1705        if (handler.oneOff) {
1706          EventHandler.off(element, event.type, selector, fn2);
1707        }
1708        return fn2.apply(target, [event]);
1709      }
1710    }
1711  };
1712}
1713function findHandler(events, callable, delegationSelector = null) {
1714  return Object.values(events).find((event) => event.callable === callable && event.delegationSelector === delegationSelector);
1715}
1716function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
1717  const isDelegated = typeof handler === "string";
1718  const callable = isDelegated ? delegationFunction : handler || delegationFunction;
1719  let typeEvent = getTypeEvent(originalTypeEvent);
1720  if (!nativeEvents.has(typeEvent)) {
1721    typeEvent = originalTypeEvent;
1722  }
1723  return [isDelegated, callable, typeEvent];
1724}
1725function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
1726  if (typeof originalTypeEvent !== "string" || !element) {
1727    return;
1728  }
1729  let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
1730  if (originalTypeEvent in customEvents) {
1731    const wrapFunction = (fn3) => {
1732      return function(event) {
1733        if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
1734          return fn3.call(this, event);
1735        }
1736      };
1737    };
1738    callable = wrapFunction(callable);
1739  }
1740  const events = getElementEvents(element);
1741  const handlers = events[typeEvent] || (events[typeEvent] = {});
1742  const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
1743  if (previousFunction) {
1744    previousFunction.oneOff = previousFunction.oneOff && oneOff;
1745    return;
1746  }
1747  const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ""));
1748  const fn2 = isDelegated ? bootstrapDelegationHandler(element, handler, callable) : bootstrapHandler(element, callable);
1749  fn2.delegationSelector = isDelegated ? handler : null;
1750  fn2.callable = callable;
1751  fn2.oneOff = oneOff;
1752  fn2.uidEvent = uid;
1753  handlers[uid] = fn2;
1754  element.addEventListener(typeEvent, fn2, isDelegated);
1755}
1756function removeHandler(element, events, typeEvent, handler, delegationSelector) {
1757  const fn2 = findHandler(events[typeEvent], handler, delegationSelector);
1758  if (!fn2) {
1759    return;
1760  }
1761  element.removeEventListener(typeEvent, fn2, Boolean(delegationSelector));
1762  delete events[typeEvent][fn2.uidEvent];
1763}
1764function removeNamespacedHandlers(element, events, typeEvent, namespace) {
1765  const storeElementEvent = events[typeEvent] || {};
1766  for (const [handlerKey, event] of Object.entries(storeElementEvent)) {
1767    if (handlerKey.includes(namespace)) {
1768      removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
1769    }
1770  }
1771}
1772function getTypeEvent(event) {
1773  event = event.replace(stripNameRegex, "");
1774  return customEvents[event] || event;
1775}
1776const EventHandler = {
1777  on(element, event, handler, delegationFunction) {
1778    addHandler(element, event, handler, delegationFunction, false);
1779  },
1780  one(element, event, handler, delegationFunction) {
1781    addHandler(element, event, handler, delegationFunction, true);
1782  },
1783  off(element, originalTypeEvent, handler, delegationFunction) {
1784    if (typeof originalTypeEvent !== "string" || !element) {
1785      return;
1786    }
1787    const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
1788    const inNamespace = typeEvent !== originalTypeEvent;
1789    const events = getElementEvents(element);
1790    const storeElementEvent = events[typeEvent] || {};
1791    const isNamespace = originalTypeEvent.startsWith(".");
1792    if (typeof callable !== "undefined") {
1793      if (!Object.keys(storeElementEvent).length) {
1794        return;
1795      }
1796      removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
1797      return;
1798    }
1799    if (isNamespace) {
1800      for (const elementEvent of Object.keys(events)) {
1801        removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
1802      }
1803    }
1804    for (const [keyHandlers, event] of Object.entries(storeElementEvent)) {
1805      const handlerKey = keyHandlers.replace(stripUidRegex, "");
1806      if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
1807        removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
1808      }
1809    }
1810  },
1811  trigger(element, event, args) {
1812    if (typeof event !== "string" || !element) {
1813      return null;
1814    }
1815    const $ = getjQuery();
1816    const typeEvent = getTypeEvent(event);
1817    const inNamespace = event !== typeEvent;
1818    let jQueryEvent = null;
1819    let bubbles = true;
1820    let nativeDispatch = true;
1821    let defaultPrevented = false;
1822    if (inNamespace && $) {
1823      jQueryEvent = $.Event(event, args);
1824      $(element).trigger(jQueryEvent);
1825      bubbles = !jQueryEvent.isPropagationStopped();
1826      nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
1827      defaultPrevented = jQueryEvent.isDefaultPrevented();
1828    }
1829    const evt = hydrateObj(new Event(event, {
1830      bubbles,
1831      cancelable: true
1832    }), args);
1833    if (defaultPrevented) {
1834      evt.preventDefault();
1835    }
1836    if (nativeDispatch) {
1837      element.dispatchEvent(evt);
1838    }
1839    if (evt.defaultPrevented && jQueryEvent) {
1840      jQueryEvent.preventDefault();
1841    }
1842    return evt;
1843  }
1844};
1845function hydrateObj(obj, meta = {}) {
1846  for (const [key, value] of Object.entries(meta)) {
1847    try {
1848      obj[key] = value;
1849    } catch (_unused) {
1850      Object.defineProperty(obj, key, {
1851        configurable: true,
1852        get() {
1853          return value;
1854        }
1855      });
1856    }
1857  }
1858  return obj;
1859}
1860function normalizeData(value) {
1861  if (value === "true") {
1862    return true;
1863  }
1864  if (value === "false") {
1865    return false;
1866  }
1867  if (value === Number(value).toString()) {
1868    return Number(value);
1869  }
1870  if (value === "" || value === "null") {
1871    return null;
1872  }
1873  if (typeof value !== "string") {
1874    return value;
1875  }
1876  try {
1877    return JSON.parse(decodeURIComponent(value));
1878  } catch (_unused) {
1879    return value;
1880  }
1881}
1882function normalizeDataKey(key) {
1883  return key.replace(/[A-Z]/g, (chr) => `-${chr.toLowerCase()}`);
1884}
1885const Manipulator = {
1886  setDataAttribute(element, key, value) {
1887    element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);
1888  },
1889  removeDataAttribute(element, key) {
1890    element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);
1891  },
1892  getDataAttributes(element) {
1893    if (!element) {
1894      return {};
1895    }
1896    const attributes = {};
1897    const bsKeys = Object.keys(element.dataset).filter((key) => key.startsWith("bs") && !key.startsWith("bsConfig"));
1898    for (const key of bsKeys) {
1899      let pureKey = key.replace(/^bs/, "");
1900      pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
1901      attributes[pureKey] = normalizeData(element.dataset[key]);
1902    }
1903    return attributes;
1904  },
1905  getDataAttribute(element, key) {
1906    return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
1907  }
1908};
1909class Config {
1910  // Getters
1911  static get Default() {
1912    return {};
1913  }
1914  static get DefaultType() {
1915    return {};
1916  }
1917  static get NAME() {
1918    throw new Error('You have to implement the static method "NAME", for each component!');
1919  }
1920  _getConfig(config) {
1921    config = this._mergeConfigObj(config);
1922    config = this._configAfterMerge(config);
1923    this._typeCheckConfig(config);
1924    return config;
1925  }
1926  _configAfterMerge(config) {
1927    return config;
1928  }
1929  _mergeConfigObj(config, element) {
1930    const jsonConfig = isElement(element) ? Manipulator.getDataAttribute(element, "config") : {};
1931    return {
1932      ...this.constructor.Default,
1933      ...typeof jsonConfig === "object" ? jsonConfig : {},
1934      ...isElement(element) ? Manipulator.getDataAttributes(element) : {},
1935      ...typeof config === "object" ? config : {}
1936    };
1937  }
1938  _typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
1939    for (const [property, expectedTypes] of Object.entries(configTypes)) {
1940      const value = config[property];
1941      const valueType = isElement(value) ? "element" : toType(value);
1942      if (!new RegExp(expectedTypes).test(valueType)) {
1943        throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`);
1944      }
1945    }
1946  }
1947}
1948const VERSION = "5.3.1";
1949class BaseComponent extends Config {
1950  constructor(element, config) {
1951    super();
1952    element = getElement(element);
1953    if (!element) {
1954      return;
1955    }
1956    this._element = element;
1957    this._config = this._getConfig(config);
1958    Data.set(this._element, this.constructor.DATA_KEY, this);
1959  }
1960  // Public
1961  dispose() {
1962    Data.remove(this._element, this.constructor.DATA_KEY);
1963    EventHandler.off(this._element, this.constructor.EVENT_KEY);
1964    for (const propertyName of Object.getOwnPropertyNames(this)) {
1965      this[propertyName] = null;
1966    }
1967  }
1968  _queueCallback(callback, element, isAnimated = true) {
1969    executeAfterTransition(callback, element, isAnimated);
1970  }
1971  _getConfig(config) {
1972    config = this._mergeConfigObj(config, this._element);
1973    config = this._configAfterMerge(config);
1974    this._typeCheckConfig(config);
1975    return config;
1976  }
1977  // Static
1978  static getInstance(element) {
1979    return Data.get(getElement(element), this.DATA_KEY);
1980  }
1981  static getOrCreateInstance(element, config = {}) {
1982    return this.getInstance(element) || new this(element, typeof config === "object" ? config : null);
1983  }
1984  static get VERSION() {
1985    return VERSION;
1986  }
1987  static get DATA_KEY() {
1988    return `bs.${this.NAME}`;
1989  }
1990  static get EVENT_KEY() {
1991    return `.${this.DATA_KEY}`;
1992  }
1993  static eventName(name) {
1994    return `${name}${this.EVENT_KEY}`;
1995  }
1996}
1997const getSelector = (element) => {
1998  let selector = element.getAttribute("data-bs-target");
1999  if (!selector || selector === "#") {
2000    let hrefAttribute = element.getAttribute("href");
2001    if (!hrefAttribute || !hrefAttribute.includes("#") && !hrefAttribute.startsWith(".")) {
2002      return null;
2003    }
2004    if (hrefAttribute.includes("#") && !hrefAttribute.startsWith("#")) {
2005      hrefAttribute = `#${hrefAttribute.split("#")[1]}`;
2006    }
2007    selector = hrefAttribute && hrefAttribute !== "#" ? hrefAttribute.trim() : null;
2008  }
2009  return parseSelector(selector);
2010};
2011const SelectorEngine = {
2012  find(selector, element = document.documentElement) {
2013    return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
2014  },
2015  findOne(selector, element = document.documentElement) {
2016    return Element.prototype.querySelector.call(element, selector);
2017  },
2018  children(element, selector) {
2019    return [].concat(...element.children).filter((child) => child.matches(selector));
2020  },
2021  parents(element, selector) {
2022    const parents = [];
2023    let ancestor = element.parentNode.closest(selector);
2024    while (ancestor) {
2025      parents.push(ancestor);
2026      ancestor = ancestor.parentNode.closest(selector);
2027    }
2028    return parents;
2029  },
2030  prev(element, selector) {
2031    let previous = element.previousElementSibling;
2032    while (previous) {
2033      if (previous.matches(selector)) {
2034        return [previous];
2035      }
2036      previous = previous.previousElementSibling;
2037    }
2038    return [];
2039  },
2040  // TODO: this is now unused; remove later along with prev()
2041  next(element, selector) {
2042    let next = element.nextElementSibling;
2043    while (next) {
2044      if (next.matches(selector)) {
2045        return [next];
2046      }
2047      next = next.nextElementSibling;
2048    }
2049    return [];
2050  },
2051  focusableChildren(element) {
2052    const focusables = ["a", "button", "input", "textarea", "select", "details", "[tabindex]", '[contenteditable="true"]'].map((selector) => `${selector}:not([tabindex^="-"])`).join(",");
2053    return this.find(focusables, element).filter((el) => !isDisabled(el) && isVisible(el));
2054  },
2055  getSelectorFromElement(element) {
2056    const selector = getSelector(element);
2057    if (selector) {
2058      return SelectorEngine.findOne(selector) ? selector : null;
2059    }
2060    return null;
2061  },
2062  getElementFromSelector(element) {
2063    const selector = getSelector(element);
2064    return selector ? SelectorEngine.findOne(selector) : null;
2065  },
2066  getMultipleElementsFromSelector(element) {
2067    const selector = getSelector(element);
2068    return selector ? SelectorEngine.find(selector) : [];
2069  }
2070};
2071const enableDismissTrigger = (component, method = "hide") => {
2072  const clickEvent = `click.dismiss${component.EVENT_KEY}`;
2073  const name = component.NAME;
2074  EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function(event) {
2075    if (["A", "AREA"].includes(this.tagName)) {
2076      event.preventDefault();
2077    }
2078    if (isDisabled(this)) {
2079      return;
2080    }
2081    const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`);
2082    const instance = component.getOrCreateInstance(target);
2083    instance[method]();
2084  });
2085};
2086const NAME$f = "alert";
2087const DATA_KEY$a = "bs.alert";
2088const EVENT_KEY$b = `.${DATA_KEY$a}`;
2089const EVENT_CLOSE = `close${EVENT_KEY$b}`;
2090const EVENT_CLOSED = `closed${EVENT_KEY$b}`;
2091const CLASS_NAME_FADE$5 = "fade";
2092const CLASS_NAME_SHOW$8 = "show";
2093class Alert extends BaseComponent {
2094  // Getters
2095  static get NAME() {
2096    return NAME$f;
2097  }
2098  // Public
2099  close() {
2100    const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
2101    if (closeEvent.defaultPrevented) {
2102      return;
2103    }
2104    this._element.classList.remove(CLASS_NAME_SHOW$8);
2105    const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
2106    this._queueCallback(() => this._destroyElement(), this._element, isAnimated);
2107  }
2108  // Private
2109  _destroyElement() {
2110    this._element.remove();
2111    EventHandler.trigger(this._element, EVENT_CLOSED);
2112    this.dispose();
2113  }
2114  // Static
2115  static jQueryInterface(config) {
2116    return this.each(function() {
2117      const data = Alert.getOrCreateInstance(this);
2118      if (typeof config !== "string") {
2119        return;
2120      }
2121      if (data[config] === void 0 || config.startsWith("_") || config === "constructor") {

2122        throw new TypeError(`No method named "${config}"`);
2123      }
2124      data[config](this);
2125    });
2126  }
2127}
2128enableDismissTrigger(Alert, "close");
2129defineJQueryPlugin(Alert);
2130const NAME$e = "button";
2131const DATA_KEY$9 = "bs.button";
2132const EVENT_KEY$a = `.${DATA_KEY$9}`;
2133const DATA_API_KEY$6 = ".data-api";
2134const CLASS_NAME_ACTIVE$3 = "active";
2135const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
2136const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`;
2137class Button extends BaseComponent {
2138  // Getters
2139  static get NAME() {
2140    return NAME$e;
2141  }
2142  // Public
2143  toggle() {
2144    this._element.setAttribute("aria-pressed", this._element.classList.toggle(CLASS_NAME_ACTIVE$3));
2145  }
2146  // Static
2147  static jQueryInterface(config) {
2148    return this.each(function() {
2149      const data = Button.getOrCreateInstance(this);
2150      if (config === "toggle") {
2151        data[config]();
2152      }
2153    });
2154  }
2155}
2156EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, (event) => {
2157  event.preventDefault();
2158  const button = event.target.closest(SELECTOR_DATA_TOGGLE$5);
2159  const data = Button.getOrCreateInstance(button);
2160  data.toggle();
2161});
2162defineJQueryPlugin(Button);
2163const NAME$d = "swipe";
2164const EVENT_KEY$9 = ".bs.swipe";
2165const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$9}`;
2166const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$9}`;
2167const EVENT_TOUCHEND = `touchend${EVENT_KEY$9}`;
2168const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$9}`;
2169const EVENT_POINTERUP = `pointerup${EVENT_KEY$9}`;
2170const POINTER_TYPE_TOUCH = "touch";
2171const POINTER_TYPE_PEN = "pen";
2172const CLASS_NAME_POINTER_EVENT = "pointer-event";
2173const SWIPE_THRESHOLD = 40;
2174const Default$c = {
2175  endCallback: null,
2176  leftCallback: null,
2177  rightCallback: null
2178};
2179const DefaultType$c = {
2180  endCallback: "(function|null)",
2181  leftCallback: "(function|null)",
2182  rightCallback: "(function|null)"
2183};
2184class Swipe extends Config {
2185  constructor(element, config) {
2186    super();
2187    this._element = element;
2188    if (!element || !Swipe.isSupported()) {
2189      return;
2190    }
2191    this._config = this._getConfig(config);
2192    this._deltaX = 0;
2193    this._supportPointerEvents = Boolean(window.PointerEvent);
2194    this._initEvents();
2195  }
2196  // Getters
2197  static get Default() {
2198    return Default$c;
2199  }
2200  static get DefaultType() {
2201    return DefaultType$c;
2202  }
2203  static get NAME() {
2204    return NAME$d;
2205  }
2206  // Public
2207  dispose() {
2208    EventHandler.off(this._element, EVENT_KEY$9);
2209  }
2210  // Private
2211  _start(event) {
2212    if (!this._supportPointerEvents) {
2213      this._deltaX = event.touches[0].clientX;
2214      return;
2215    }
2216    if (this._eventIsPointerPenTouch(event)) {
2217      this._deltaX = event.clientX;
2218    }
2219  }
2220  _end(event) {
2221    if (this._eventIsPointerPenTouch(event)) {
2222      this._deltaX = event.clientX - this._deltaX;
2223    }
2224    this._handleSwipe();
2225    execute(this._config.endCallback);
2226  }
2227  _move(event) {
2228    this._deltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this._deltaX;
2229  }
2230  _handleSwipe() {
2231    const absDeltaX = Math.abs(this._deltaX);
2232    if (absDeltaX <= SWIPE_THRESHOLD) {
2233      return;
2234    }
2235    const direction = absDeltaX / this._deltaX;
2236    this._deltaX = 0;
2237    if (!direction) {
2238      return;
2239    }
2240    execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback);
2241  }
2242  _initEvents() {
2243    if (this._supportPointerEvents) {
2244      EventHandler.on(this._element, EVENT_POINTERDOWN, (event) => this._start(event));
2245      EventHandler.on(this._element, EVENT_POINTERUP, (event) => this._end(event));
2246      this._element.classList.add(CLASS_NAME_POINTER_EVENT);
2247    } else {
2248      EventHandler.on(this._element, EVENT_TOUCHSTART, (event) => this._start(event));
2249      EventHandler.on(this._element, EVENT_TOUCHMOVE, (event) => this._move(event));
2250      EventHandler.on(this._element, EVENT_TOUCHEND, (event) => this._end(event));
2251    }
2252  }
2253  _eventIsPointerPenTouch(event) {
2254    return this._supportPointerEvents && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH);
2255  }
2256  // Static
2257  static isSupported() {
2258    return "ontouchstart" in document.documentElement || navigator.maxTouchPoints > 0;
2259  }
2260}
2261const NAME$c = "carousel";
2262const DATA_KEY$8 = "bs.carousel";
2263const EVENT_KEY$8 = `.${DATA_KEY$8}`;
2264const DATA_API_KEY$5 = ".data-api";
2265const ARROW_LEFT_KEY$1 = "ArrowLeft";
2266const ARROW_RIGHT_KEY$1 = "ArrowRight";
2267const TOUCHEVENT_COMPAT_WAIT = 500;
2268const ORDER_NEXT = "next";
2269const ORDER_PREV = "prev";
2270const DIRECTION_LEFT = "left";
2271const DIRECTION_RIGHT = "right";
2272const EVENT_SLIDE = `slide${EVENT_KEY$8}`;
2273const EVENT_SLID = `slid${EVENT_KEY$8}`;
2274const EVENT_KEYDOWN$1 = `keydown${EVENT_KEY$8}`;
2275const EVENT_MOUSEENTER$1 = `mouseenter${EVENT_KEY$8}`;
2276const EVENT_MOUSELEAVE$1 = `mouseleave${EVENT_KEY$8}`;
2277const EVENT_DRAG_START = `dragstart${EVENT_KEY$8}`;
2278const EVENT_LOAD_DATA_API$3 = `load${EVENT_KEY$8}${DATA_API_KEY$5}`;
2279const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`;
2280const CLASS_NAME_CAROUSEL = "carousel";
2281const CLASS_NAME_ACTIVE$2 = "active";
2282const CLASS_NAME_SLIDE = "slide";
2283const CLASS_NAME_END = "carousel-item-end";
2284const CLASS_NAME_START = "carousel-item-start";
2285const CLASS_NAME_NEXT = "carousel-item-next";
2286const CLASS_NAME_PREV = "carousel-item-prev";
2287const SELECTOR_ACTIVE = ".active";
2288const SELECTOR_ITEM = ".carousel-item";
2289const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_ITEM;
2290const SELECTOR_ITEM_IMG = ".carousel-item img";
2291const SELECTOR_INDICATORS = ".carousel-indicators";
2292const SELECTOR_DATA_SLIDE = "[data-bs-slide], [data-bs-slide-to]";
2293const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
2294const KEY_TO_DIRECTION = {
2295  [ARROW_LEFT_KEY$1]: DIRECTION_RIGHT,
2296  [ARROW_RIGHT_KEY$1]: DIRECTION_LEFT
2297};
2298const Default$b = {
2299  interval: 5e3,
2300  keyboard: true,
2301  pause: "hover",
2302  ride: false,
2303  touch: true,
2304  wrap: true
2305};
2306const DefaultType$b = {
2307  interval: "(number|boolean)",

2308  // TODO:v6 remove boolean support
2309  keyboard: "boolean",
2310  pause: "(string|boolean)",
2311  ride: "(boolean|string)",
2312  touch: "boolean",
2313  wrap: "boolean"
2314};
2315class Carousel extends BaseComponent {
2316  constructor(element, config) {
2317    super(element, config);
2318    this._interval = null;
2319    this._activeElement = null;
2320    this._isSliding = false;
2321    this.touchTimeout = null;
2322    this._swipeHelper = null;
2323    this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
2324    this._addEventListeners();
2325    if (this._config.ride === CLASS_NAME_CAROUSEL) {
2326      this.cycle();
2327    }
2328  }
2329  // Getters
2330  static get Default() {
2331    return Default$b;
2332  }
2333  static get DefaultType() {
2334    return DefaultType$b;
2335  }
2336  static get NAME() {
2337    return NAME$c;
2338  }
2339  // Public
2340  next() {
2341    this._slide(ORDER_NEXT);
2342  }
2343  nextWhenVisible() {
2344    if (!document.hidden && isVisible(this._element)) {
2345      this.next();
2346    }
2347  }
2348  prev() {
2349    this._slide(ORDER_PREV);
2350  }
2351  pause() {
2352    if (this._isSliding) {
2353      triggerTransitionEnd(this._element);
2354    }
2355    this._clearInterval();
2356  }
2357  cycle() {
2358    this._clearInterval();
2359    this._updateInterval();
2360    this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);
2361  }
2362  _maybeEnableCycle() {
2363    if (!this._config.ride) {
2364      return;
2365    }
2366    if (this._isSliding) {
2367      EventHandler.one(this._element, EVENT_SLID, () => this.cycle());
2368      return;
2369    }
2370    this.cycle();
2371  }
2372  to(index) {
2373    const items = this._getItems();
2374    if (index > items.length - 1 || index < 0) {
2375      return;
2376    }
2377    if (this._isSliding) {
2378      EventHandler.one(this._element, EVENT_SLID, () => this.to(index));
2379      return;
2380    }
2381    const activeIndex = this._getItemIndex(this._getActive());
2382    if (activeIndex === index) {
2383      return;
2384    }
2385    const order2 = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
2386    this._slide(order2, items[index]);
2387  }
2388  dispose() {
2389    if (this._swipeHelper) {
2390      this._swipeHelper.dispose();
2391    }
2392    super.dispose();
2393  }
2394  // Private
2395  _configAfterMerge(config) {
2396    config.defaultInterval = config.interval;
2397    return config;
2398  }
2399  _addEventListeners() {
2400    if (this._config.keyboard) {
2401      EventHandler.on(this._element, EVENT_KEYDOWN$1, (event) => this._keydown(event));
2402    }
2403    if (this._config.pause === "hover") {
2404      EventHandler.on(this._element, EVENT_MOUSEENTER$1, () => this.pause());
2405      EventHandler.on(this._element, EVENT_MOUSELEAVE$1, () => this._maybeEnableCycle());
2406    }
2407    if (this._config.touch && Swipe.isSupported()) {
2408      this._addTouchEventListeners();
2409    }
2410  }
2411  _addTouchEventListeners() {
2412    for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {
2413      EventHandler.on(img, EVENT_DRAG_START, (event) => event.preventDefault());
2414    }
2415    const endCallBack = () => {
2416      if (this._config.pause !== "hover") {
2417        return;
2418      }
2419      this.pause();
2420      if (this.touchTimeout) {
2421        clearTimeout(this.touchTimeout);
2422      }
2423      this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval);
2424    };
2425    const swipeConfig = {
2426      leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
2427      rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
2428      endCallback: endCallBack
2429    };
2430    this._swipeHelper = new Swipe(this._element, swipeConfig);
2431  }
2432  _keydown(event) {
2433    if (/input|textarea/i.test(event.target.tagName)) {
2434      return;
2435    }
2436    const direction = KEY_TO_DIRECTION[event.key];
2437    if (direction) {
2438      event.preventDefault();
2439      this._slide(this._directionToOrder(direction));
2440    }
2441  }
2442  _getItemIndex(element) {
2443    return this._getItems().indexOf(element);
2444  }
2445  _setActiveIndicatorElement(index) {
2446    if (!this._indicatorsElement) {
2447      return;
2448    }
2449    const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
2450    activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);
2451    activeIndicator.removeAttribute("aria-current");
2452    const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement);
2453    if (newActiveIndicator) {
2454      newActiveIndicator.classList.add(CLASS_NAME_ACTIVE$2);
2455      newActiveIndicator.setAttribute("aria-current", "true");
2456    }
2457  }
2458  _updateInterval() {
2459    const element = this._activeElement || this._getActive();
2460    if (!element) {
2461      return;
2462    }
2463    const elementInterval = Number.parseInt(element.getAttribute("data-bs-interval"), 10);
2464    this._config.interval = elementInterval || this._config.defaultInterval;
2465  }
2466  _slide(order2, element = null) {
2467    if (this._isSliding) {
2468      return;
2469    }
2470    const activeElement = this._getActive();
2471    const isNext = order2 === ORDER_NEXT;
2472    const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);
2473    if (nextElement === activeElement) {
2474      return;
2475    }
2476    const nextElementIndex = this._getItemIndex(nextElement);
2477    const triggerEvent = (eventName) => {
2478      return EventHandler.trigger(this._element, eventName, {
2479        relatedTarget: nextElement,
2480        direction: this._orderToDirection(order2),
2481        from: this._getItemIndex(activeElement),
2482        to: nextElementIndex
2483      });
2484    };
2485    const slideEvent = triggerEvent(EVENT_SLIDE);
2486    if (slideEvent.defaultPrevented) {
2487      return;
2488    }
2489    if (!activeElement || !nextElement) {
2490      return;
2491    }
2492    const isCycling = Boolean(this._interval);
2493    this.pause();
2494    this._isSliding = true;
2495    this._setActiveIndicatorElement(nextElementIndex);
2496    this._activeElement = nextElement;
2497    const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
2498    const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
2499    nextElement.classList.add(orderClassName);
2500    reflow(nextElement);
2501    activeElement.classList.add(directionalClassName);
2502    nextElement.classList.add(directionalClassName);
2503    const completeCallBack = () => {
2504      nextElement.classList.remove(directionalClassName, orderClassName);
2505      nextElement.classList.add(CLASS_NAME_ACTIVE$2);
2506      activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
2507      this._isSliding = false;

2508      triggerEvent(EVENT_SLID);
2509    };
2510    this._queueCallback(completeCallBack, activeElement, this._isAnimated());
2511    if (isCycling) {
2512      this.cycle();
2513    }
2514  }
2515  _isAnimated() {
2516    return this._element.classList.contains(CLASS_NAME_SLIDE);
2517  }
2518  _getActive() {
2519    return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
2520  }
2521  _getItems() {
2522    return SelectorEngine.find(SELECTOR_ITEM, this._element);
2523  }
2524  _clearInterval() {
2525    if (this._interval) {
2526      clearInterval(this._interval);
2527      this._interval = null;
2528    }
2529  }
2530  _directionToOrder(direction) {
2531    if (isRTL()) {
2532      return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
2533    }
2534    return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
2535  }
2536  _orderToDirection(order2) {
2537    if (isRTL()) {
2538      return order2 === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
2539    }
2540    return order2 === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
2541  }
2542  // Static
2543  static jQueryInterface(config) {
2544    return this.each(function() {
2545      const data = Carousel.getOrCreateInstance(this, config);
2546      if (typeof config === "number") {
2547        data.to(config);
2548        return;
2549      }
2550      if (typeof config === "string") {
2551        if (data[config] === void 0 || config.startsWith("_") || config === "constructor") {
2552          throw new TypeError(`No method named "${config}"`);
2553        }
2554        data[config]();
2555      }
2556    });
2557  }
2558}
2559EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, function(event) {
2560  const target = SelectorEngine.getElementFromSelector(this);
2561  if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
2562    return;
2563  }
2564  event.preventDefault();
2565  const carousel = Carousel.getOrCreateInstance(target);
2566  const slideIndex = this.getAttribute("data-bs-slide-to");
2567  if (slideIndex) {
2568    carousel.to(slideIndex);
2569    carousel._maybeEnableCycle();
2570    return;
2571  }
2572  if (Manipulator.getDataAttribute(this, "slide") === "next") {
2573    carousel.next();
2574    carousel._maybeEnableCycle();
2575    return;
2576  }
2577  carousel.prev();
2578  carousel._maybeEnableCycle();
2579});
2580EventHandler.on(window, EVENT_LOAD_DATA_API$3, () => {
2581  const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
2582  for (const carousel of carousels) {

2583    Carousel.getOrCreateInstance(carousel);
2584  }
2585});
2586defineJQueryPlugin(Carousel);
2587const NAME$b = "collapse";
2588const DATA_KEY$7 = "bs.collapse";
2589const EVENT_KEY$7 = `.${DATA_KEY$7}`;
2590const DATA_API_KEY$4 = ".data-api";
2591const EVENT_SHOW$6 = `show${EVENT_KEY$7}`;
2592const EVENT_SHOWN$6 = `shown${EVENT_KEY$7}`;
2593const EVENT_HIDE$6 = `hide${EVENT_KEY$7}`;
2594const EVENT_HIDDEN$6 = `hidden${EVENT_KEY$7}`;
2595const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`;
2596const CLASS_NAME_SHOW$7 = "show";
2597const CLASS_NAME_COLLAPSE = "collapse";
2598const CLASS_NAME_COLLAPSING = "collapsing";
2599const CLASS_NAME_COLLAPSED = "collapsed";
2600const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`;
2601const CLASS_NAME_HORIZONTAL = "collapse-horizontal";
2602const WIDTH = "width";
2603const HEIGHT = "height";
2604const SELECTOR_ACTIVES = ".collapse.show, .collapse.collapsing";
2605const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]';
2606const Default$a = {
2607  parent: null,
2608  toggle: true
2609};
2610const DefaultType$a = {
2611  parent: "(null|element)",
2612  toggle: "boolean"
2613};
2614class Collapse extends BaseComponent {
2615  constructor(element, config) {
2616    super(element, config);
2617    this._isTransitioning = false;
2618    this._triggerArray = [];
2619    const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);
2620    for (const elem of toggleList) {
2621      const selector = SelectorEngine.getSelectorFromElement(elem);
2622      const filterElement = SelectorEngine.find(selector).filter((foundElement) => foundElement === this._element);
2623      if (selector !== null && filterElement.length) {
2624        this._triggerArray.push(elem);
2625      }
2626    }
2627    this._initializeChildren();
2628    if (!this._config.parent) {
2629      this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());
2630    }
2631    if (this._config.toggle) {
2632      this.toggle();
2633    }
2634  }
2635  // Getters
2636  static get Default() {
2637    return Default$a;
2638  }
2639  static get DefaultType() {
2640    return DefaultType$a;
2641  }
2642  static get NAME() {
2643    return NAME$b;
2644  }
2645  // Public
2646  toggle() {
2647    if (this._isShown()) {
2648      this.hide();
2649    } else {
2650      this.show();
2651    }
2652  }
2653  show() {
2654    if (this._isTransitioning || this._isShown()) {
2655      return;
2656    }
2657    let activeChildren = [];
2658    if (this._config.parent) {
2659      activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES).filter((element) => element !== this._element).map((element) => Collapse.getOrCreateInstance(element, {
2660        toggle: false
2661      }));
2662    }
2663    if (activeChildren.length && activeChildren[0]._isTransitioning) {
2664      return;
2665    }
2666    const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$6);
2667    if (startEvent.defaultPrevented) {
2668      return;
2669    }
2670    for (const activeInstance of activeChildren) {
2671      activeInstance.hide();
2672    }
2673    const dimension = this._getDimension();
2674    this._element.classList.remove(CLASS_NAME_COLLAPSE);
2675    this._element.classList.add(CLASS_NAME_COLLAPSING);
2676    this._element.style[dimension] = 0;
2677    this._addAriaAndCollapsedClass(this._triggerArray, true);
2678    this._isTransitioning = true;
2679    const complete = () => {
2680      this._isTransitioning = false;
2681      this._element.classList.remove(CLASS_NAME_COLLAPSING);
2682      this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
2683      this._element.style[dimension] = "";
2684      EventHandler.trigger(this._element, EVENT_SHOWN$6);
2685    };
2686    const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
2687    const scrollSize = `scroll${capitalizedDimension}`;
2688    this._queueCallback(complete, this._element, true);
2689    this._element.style[dimension] = `${this._element[scrollSize]}px`;
2690  }
2691  hide() {
2692    if (this._isTransitioning || !this._isShown()) {
2693      return;
2694    }
2695    const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6);
2696    if (startEvent.defaultPrevented) {
2697      return;
2698    }
2699    const dimension = this._getDimension();
2700    this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;
2701    reflow(this._element);
2702    this._element.classList.add(CLASS_NAME_COLLAPSING);
2703    this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
2704    for (const trigger of this._triggerArray) {
2705      const element = SelectorEngine.getElementFromSelector(trigger);
2706      if (element && !this._isShown(element)) {
2707        this._addAriaAndCollapsedClass([trigger], false);
2708      }
2709    }
2710    this._isTransitioning = true;
2711    const complete = () => {
2712      this._isTransitioning = false;