https://magicpods.app/contact/

1078        if (node === getWindow(node) || !isHTMLElement(node)) {
1079          return getWindowScroll(node);
1080        } else {
1081          return getHTMLElementScroll(node);
1082        }
1083      }
1084      function getNodeName(element) {
1085        return element ? (element.nodeName || "").toLowerCase() : null;
1086      }
1087      function getDocumentElement(element) {
1088        return ((isElement2(element) ? element.ownerDocument : (
1089          // $FlowFixMe[prop-missing]
1090          element.document
1091        )) || window.document).documentElement;
1092      }
1093      function getWindowScrollBarX(element) {
1094        return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
1095      }
1096      function getComputedStyle2(element) {
1097        return getWindow(element).getComputedStyle(element);
1098      }
1099      function isScrollParent(element) {
1100        var _getComputedStyle = getComputedStyle2(element), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY;
1101        return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
1102      }
1103      function isElementScaled(element) {
1104        var rect = element.getBoundingClientRect();
1105        var scaleX = round(rect.width) / element.offsetWidth || 1;
1106        var scaleY = round(rect.height) / element.offsetHeight || 1;
1107        return scaleX !== 1 || scaleY !== 1;
1108      }
1109      function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
1110        if (isFixed === void 0) {
1111          isFixed = false;
1112        }
1113        var isOffsetParentAnElement = isHTMLElement(offsetParent);
1114        var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
1115        var documentElement = getDocumentElement(offsetParent);
1116        var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled);
1117        var scroll = {
1118          scrollLeft: 0,
1119          scrollTop: 0
1120        };
1121        var offsets = {
1122          x: 0,
1123          y: 0
1124        };
1125        if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
1126          if (getNodeName(offsetParent) !== "body" || // https://github.com/popperjs/popper-core/issues/1078
1127          isScrollParent(documentElement)) {
1128            scroll = getNodeScroll(offsetParent);
1129          }
1130          if (isHTMLElement(offsetParent)) {
1131            offsets = getBoundingClientRect(offsetParent, true);
1132            offsets.x += offsetParent.clientLeft;
1133            offsets.y += offsetParent.clientTop;
1134          } else if (documentElement) {
1135            offsets.x = getWindowScrollBarX(documentElement);
1136          }
1137        }
1138        return {
1139          x: rect.left + scroll.scrollLeft - offsets.x,
1140          y: rect.top + scroll.scrollTop - offsets.y,
1141          width: rect.width,
1142          height: rect.height
1143        };
1144      }
1145      function getLayoutRect(element) {
1146        var clientRect = getBoundingClientRect(element);
1147        var width = element.offsetWidth;
1148        var height = element.offsetHeight;
1149        if (Math.abs(clientRect.width - width) <= 1) {
1150          width = clientRect.width;
1151        }
1152        if (Math.abs(clientRect.height - height) <= 1) {
1153          height = clientRect.height;
1154        }
1155        return {
1156          x: element.offsetLeft,
1157          y: element.offsetTop,
1158          width,
1159          height
1160        };
1161      }
1162      function getParentNode(element) {
1163        if (getNodeName(element) === "html") {
1164          return element;
1165        }
1166        return (
1167          // this is a quicker (but less type safe) way to save quite some bytes from the bundle
1168          // $FlowFixMe[incompatible-return]
1169          // $FlowFixMe[prop-missing]
1170          element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
1171          element.parentNode || // DOM Element detected
1172          (isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
1173          // $FlowFixMe[incompatible-call]: HTMLElement is a Node
1174          getDocumentElement(element)
1175        );
1176      }
1177      function getScrollParent(node) {
1178        if (["html", "body", "#document"].indexOf(getNodeName(node)) >= 0) {
1179          return node.ownerDocument.body;
1180        }
1181        if (isHTMLElement(node) && isScrollParent(node)) {
1182          return node;
1183        }
1184        return getScrollParent(getParentNode(node));
1185      }
1186      function listScrollParents(element, list) {
1187        var _element$ownerDocumen;
1188        if (list === void 0) {
1189          list = [];
1190        }
1191        var scrollParent = getScrollParent(element);
1192        var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
1193        var win = getWindow(scrollParent);

1194        var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
1195        var updatedList = list.concat(target);
1196        return isBody ? updatedList : (
1197          // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
1198          updatedList.concat(listScrollParents(getParentNode(target)))
1199        );
1200      }
1201      function isTableElement(element) {
1202        return ["table", "td", "th"].indexOf(getNodeName(element)) >= 0;
1203      }
1204      function getTrueOffsetParent(element) {
1205        if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
1206        getComputedStyle2(element).position === "fixed") {
1207          return null;
1208        }
1209        return element.offsetParent;
1210      }
1211      function getContainingBlock(element) {
1212        var isFirefox = navigator.userAgent.toLowerCase().indexOf("firefox") !== -1;
1213        var isIE = navigator.userAgent.indexOf("Trident") !== -1;
1214        if (isIE && isHTMLElement(element)) {
1215          var elementCss = getComputedStyle2(element);
1216          if (elementCss.position === "fixed") {
1217            return null;
1218          }
1219        }
1220        var currentNode = getParentNode(element);
1221        while (isHTMLElement(currentNode) && ["html", "body"].indexOf(getNodeName(currentNode)) < 0) {
1222          var css = getComputedStyle2(currentNode);
1223          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") {
1224            return currentNode;
1225          } else {
1226            currentNode = currentNode.parentNode;
1227          }
1228        }
1229        return null;
1230      }
1231      function getOffsetParent(element) {
1232        var window2 = getWindow(element);
1233        var offsetParent = getTrueOffsetParent(element);
1234        while (offsetParent && isTableElement(offsetParent) && getComputedStyle2(offsetParent).position === "static") {
1235          offsetParent = getTrueOffsetParent(offsetParent);
1236        }
1237        if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle2(offsetParent).position === "static")) {
1238          return window2;
1239        }
1240        return offsetParent || getContainingBlock(element) || window2;
1241      }
1242      var top = "top";
1243      var bottom = "bottom";
1244      var right = "right";
1245      var left = "left";
1246      var auto = "auto";
1247      var basePlacements = [top, bottom, right, left];
1248      var start = "start";
1249      var end = "end";
1250      var clippingParents = "clippingParents";
1251      var viewport = "viewport";
1252      var popper = "popper";
1253      var reference = "reference";
1254      var variationPlacements = /* @__PURE__ */ basePlacements.reduce(function(acc, placement) {
1255        return acc.concat([placement + "-" + start, placement + "-" + end]);
1256      }, []);
1257      var placements = /* @__PURE__ */ [].concat(basePlacements, [auto]).reduce(function(acc, placement) {
1258        return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
1259      }, []);
1260      var beforeRead = "beforeRead";
1261      var read = "read";
1262      var afterRead = "afterRead";
1263      var beforeMain = "beforeMain";
1264      var main = "main";
1265      var afterMain = "afterMain";
1266      var beforeWrite = "beforeWrite";
1267      var write = "write";
1268      var afterWrite = "afterWrite";
1269      var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
1270      function order(modifiers) {
1271        var map = /* @__PURE__ */ new Map();
1272        var visited = /* @__PURE__ */ new Set();
1273        var result = [];
1274        modifiers.forEach(function(modifier) {
1275          map.set(modifier.name, modifier);
1276        });
1277        function sort(modifier) {
1278          visited.add(modifier.name);
1279          var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
1280          requires.forEach(function(dep) {
1281            if (!visited.has(dep)) {
1282              var depModifier = map.get(dep);
1283              if (depModifier) {
1284                sort(depModifier);
1285              }
1286            }
1287          });
1288          result.push(modifier);
1289        }

1290        modifiers.forEach(function(modifier) {
1291          if (!visited.has(modifier.name)) {
1292            sort(modifier);
1293          }
1294        });
1295        return result;
1296      }
1297      function orderModifiers(modifiers) {
1298        var orderedModifiers = order(modifiers);
1299        return modifierPhases.reduce(function(acc, phase) {
1300          return acc.concat(orderedModifiers.filter(function(modifier) {
1301            return modifier.phase === phase;
1302          }));
1303        }, []);
1304      }
1305      function debounce(fn) {
1306        var pending;
1307        return function() {
1308          if (!pending) {
1309            pending = new Promise(function(resolve) {
1310              Promise.resolve().then(function() {
1311                pending = void 0;
1312                resolve(fn());
1313              });
1314            });
1315          }
1316          return pending;
1317        };
1318      }
1319      function format(str) {
1320        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
1321          args[_key - 1] = arguments[_key];
1322        }
1323        return [].concat(args).reduce(function(p, c) {
1324          return p.replace(/%s/, c);
1325        }, str);
1326      }
1327      var INVALID_MODIFIER_ERROR = 'Popper: modifier "%s" provided an invalid %s property, expected %s but got %s';
1328      var MISSING_DEPENDENCY_ERROR = 'Popper: modifier "%s" requires "%s", but "%s" modifier is not available';
1329      var VALID_PROPERTIES = ["name", "enabled", "phase", "fn", "effect", "requires", "options"];
1330      function validateModifiers(modifiers) {
1331        modifiers.forEach(function(modifier) {
1332          [].concat(Object.keys(modifier), VALID_PROPERTIES).filter(function(value, index, self) {
1333            return self.indexOf(value) === index;
1334          }).forEach(function(key) {
1335            switch (key) {
1336              case "name":
1337                if (typeof modifier.name !== "string") {
1338                  console.error(format(INVALID_MODIFIER_ERROR, String(modifier.name), '"name"', '"string"', '"' + String(modifier.name) + '"'));
1339                }
1340                break;
1341              case "enabled":
1342                if (typeof modifier.enabled !== "boolean") {
1343                  console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"enabled"', '"boolean"', '"' + String(modifier.enabled) + '"'));
1344                }
1345                break;
1346              case "phase":
1347                if (modifierPhases.indexOf(modifier.phase) < 0) {
1348                  console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"phase"', "either " + modifierPhases.join(", "), '"' + String(modifier.phase) + '"'));
1349                }
1350                break;
1351              case "fn":
1352                if (typeof modifier.fn !== "function") {
1353                  console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"fn"', '"function"', '"' + String(modifier.fn) + '"'));
1354                }
1355                break;
1356              case "effect":
1357                if (modifier.effect != null && typeof modifier.effect !== "function") {
1358                  console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"effect"', '"function"', '"' + String(modifier.fn) + '"'));
1359                }
1360                break;
1361              case "requires":
1362                if (modifier.requires != null && !Array.isArray(modifier.requires)) {
1363                  console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requires"', '"array"', '"' + String(modifier.requires) + '"'));
1364                }
1365                break;
1366              case "requiresIfExists":
1367                if (!Array.isArray(modifier.requiresIfExists)) {
1368                  console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requiresIfExists"', '"array"', '"' + String(modifier.requiresIfExists) + '"'));
1369                }
1370                break;
1371              case "options":
1372              case "data":
1373                break;
1374              default:
1375                console.error('PopperJS: an invalid property has been provided to the "' + modifier.name + '" modifier, valid properties are ' + VALID_PROPERTIES.map(function(s) {
1376                  return '"' + s + '"';
1377                }).join(", ") + '; but "' + key + '" was provided.');
1378            }
1379            modifier.requires && modifier.requires.forEach(function(requirement) {
1380              if (modifiers.find(function(mod) {
1381                return mod.name === requirement;
1382              }) == null) {
1383                console.error(format(MISSING_DEPENDENCY_ERROR, String(modifier.name), requirement, requirement));
1384              }
1385            });
1386          });
1387        });
1388      }
1389      function uniqueBy(arr, fn) {
1390        var identifiers = /* @__PURE__ */ new Set();
1391        return arr.filter(function(item) {
1392          var identifier = fn(item);
1393          if (!identifiers.has(identifier)) {
1394            identifiers.add(identifier);
1395            return true;
1396          }
1397        });
1398      }
1399      function getBasePlacement(placement) {
1400        return placement.split("-")[0];
1401      }
1402      function mergeByName(modifiers) {
1403        var merged = modifiers.reduce(function(merged2, current) {
1404          var existing = merged2[current.name];
1405          merged2[current.name] = existing ? Object.assign({}, existing, current, {
1406            options: Object.assign({}, existing.options, current.options),
1407            data: Object.assign({}, existing.data, current.data)
1408          }) : current;
1409          return merged2;
1410        }, {});
1411        return Object.keys(merged).map(function(key) {
1412          return merged[key];
1413        });
1414      }
1415      function getViewportRect(element) {
1416        var win = getWindow(element);
1417        var html = getDocumentElement(element);
1418        var visualViewport = win.visualViewport;
1419        var width = html.clientWidth;
1420        var height = html.clientHeight;
1421        var x = 0;
1422        var y = 0;

1423        if (visualViewport) {
1424          width = visualViewport.width;
1425          height = visualViewport.height;
1426          if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
1427            x = visualViewport.offsetLeft;
1428            y = visualViewport.offsetTop;
1429          }
1430        }
1431        return {
1432          width,
1433          height,
1434          x: x + getWindowScrollBarX(element),
1435          y
1436        };
1437      }
1438      function getDocumentRect(element) {
1439        var _element$ownerDocumen;
1440        var html = getDocumentElement(element);
1441        var winScroll = getWindowScroll(element);
1442        var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
1443        var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
1444        var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
1445        var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
1446        var y = -winScroll.scrollTop;
1447        if (getComputedStyle2(body || html).direction === "rtl") {
1448          x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
1449        }
1450        return {
1451          width,
1452          height,
1453          x,
1454          y
1455        };
1456      }
1457      function contains(parent, child) {
1458        var rootNode = child.getRootNode && child.getRootNode();
1459        if (parent.contains(child)) {
1460          return true;
1461        } else if (rootNode && isShadowRoot(rootNode)) {
1462          var next = child;
1463          do {
1464            if (next && parent.isSameNode(next)) {
1465              return true;
1466            }
1467            next = next.parentNode || next.host;
1468          } while (next);
1469        }
1470        return false;
1471      }
1472      function rectToClientRect(rect) {
1473        return Object.assign({}, rect, {
1474          left: rect.x,
1475          top: rect.y,
1476          right: rect.x + rect.width,
1477          bottom: rect.y + rect.height
1478        });
1479      }
1480      function getInnerBoundingClientRect(element) {
1481        var rect = getBoundingClientRect(element);
1482        rect.top = rect.top + element.clientTop;
1483        rect.left = rect.left + element.clientLeft;
1484        rect.bottom = rect.top + element.clientHeight;
1485        rect.right = rect.left + element.clientWidth;
1486        rect.width = element.clientWidth;
1487        rect.height = element.clientHeight;
1488        rect.x = rect.left;
1489        rect.y = rect.top;
1490        return rect;
1491      }
1492      function getClientRectFromMixedType(element, clippingParent) {
1493        return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isElement2(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
1494      }
1495      function getClippingParents(element) {
1496        var clippingParents2 = listScrollParents(getParentNode(element));
1497        var canEscapeClipping = ["absolute", "fixed"].indexOf(getComputedStyle2(element).position) >= 0;
1498        var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
1499        if (!isElement2(clipperElement)) {
1500          return [];
1501        }
1502        return clippingParents2.filter(function(clippingParent) {
1503          return isElement2(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== "body" && (canEscapeClipping ? getComputedStyle2(clippingParent).position !== "static" : true);
1504        });
1505      }
1506      function getClippingRect(element, boundary, rootBoundary) {
1507        var mainClippingParents = boundary === "clippingParents" ? getClippingParents(element) : [].concat(boundary);
1508        var clippingParents2 = [].concat(mainClippingParents, [rootBoundary]);
1509        var firstClippingParent = clippingParents2[0];
1510        var clippingRect = clippingParents2.reduce(function(accRect, clippingParent) {
1511          var rect = getClientRectFromMixedType(element, clippingParent);
1512          accRect.top = max(rect.top, accRect.top);
1513          accRect.right = min(rect.right, accRect.right);
1514          accRect.bottom = min(rect.bottom, accRect.bottom);
1515          accRect.left = max(rect.left, accRect.left);
1516          return accRect;
1517        }, getClientRectFromMixedType(element, firstClippingParent));
1518        clippingRect.width = clippingRect.right - clippingRect.left;
1519        clippingRect.height = clippingRect.bottom - clippingRect.top;
1520        clippingRect.x = clippingRect.left;
1521        clippingRect.y = clippingRect.top;
1522        return clippingRect;
1523      }
1524      function getVariation(placement) {
1525        return placement.split("-")[1];
1526      }
1527      function getMainAxisFromPlacement(placement) {
1528        return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y";
1529      }
1530      function computeOffsets(_ref) {
1531        var reference2 = _ref.reference, element = _ref.element, placement = _ref.placement;
1532        var basePlacement = placement ? getBasePlacement(placement) : null;
1533        var variation = placement ? getVariation(placement) : null;
1534        var commonX = reference2.x + reference2.width / 2 - element.width / 2;
1535        var commonY = reference2.y + reference2.height / 2 - element.height / 2;
1536        var offsets;
1537        switch (basePlacement) {
1538          case top:
1539            offsets = {
1540              x: commonX,
1541              y: reference2.y - element.height
1542            };
1543            break;
1544          case bottom:
1545            offsets = {
1546              x: commonX,
1547              y: reference2.y + reference2.height
1548            };
1549            break;
1550          case right:
1551            offsets = {
1552              x: reference2.x + reference2.width,
1553              y: commonY
1554            };
1555            break;
1556          case left:
1557            offsets = {
1558              x: reference2.x - element.width,
1559              y: commonY
1560            };
1561            break;
1562          default:
1563            offsets = {
1564              x: reference2.x,
1565              y: reference2.y
1566            };
1567        }
1568        var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
1569        if (mainAxis != null) {
1570          var len = mainAxis === "y" ? "height" : "width";
1571          switch (variation) {
1572            case start:
1573              offsets[mainAxis] = offsets[mainAxis] - (reference2[len] / 2 - element[len] / 2);
1574              break;
1575            case end:
1576              offsets[mainAxis] = offsets[mainAxis] + (reference2[len] / 2 - element[len] / 2);
1577              break;
1578          }
1579        }
1580        return offsets;
1581      }
1582      function getFreshSideObject() {
1583        return {
1584          top: 0,
1585          right: 0,
1586          bottom: 0,
1587          left: 0
1588        };
1589      }
1590      function mergePaddingObject(paddingObject) {
1591        return Object.assign({}, getFreshSideObject(), paddingObject);
1592      }
1593      function expandToHashMap(value, keys) {
1594        return keys.reduce(function(hashMap, key) {
1595          hashMap[key] = value;
1596          return hashMap;
1597        }, {});
1598      }
1599      function detectOverflow(state, options) {
1600        if (options === void 0) {
1601          options = {};
1602        }
1603        var _options = options, _options$placement = _options.placement, placement = _options$placement === void 0 ? state.placement : _options$placement, _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;
1604        var paddingObject = mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
1605        var altContext = elementContext === popper ? reference : popper;
1606        var popperRect = state.rects.popper;
1607        var element = state.elements[altBoundary ? altContext : elementContext];
1608        var clippingClientRect = getClippingRect(isElement2(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary);
1609        var referenceClientRect = getBoundingClientRect(state.elements.reference);
1610        var popperOffsets2 = computeOffsets({
1611          reference: referenceClientRect,
1612          element: popperRect,
1613          strategy: "absolute",
1614          placement
1615        });
1616        var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets2));
1617        var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect;
1618        var overflowOffsets = {
1619          top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
1620          bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
1621          left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
1622          right: elementClientRect.right - clippingClientRect.right + paddingObject.right
1623        };
1624        var offsetData = state.modifiersData.offset;
1625        if (elementContext === popper && offsetData) {
1626          var offset2 = offsetData[placement];
1627          Object.keys(overflowOffsets).forEach(function(key) {
1628            var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
1629            var axis = [top, bottom].indexOf(key) >= 0 ? "y" : "x";
1630            overflowOffsets[key] += offset2[axis] * multiply;
1631          });
1632        }
1633        return overflowOffsets;
1634      }
1635      var INVALID_ELEMENT_ERROR = "Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.";
1636      var INFINITE_LOOP_ERROR = "Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.";
1637      var DEFAULT_OPTIONS = {
1638        placement: "bottom",
1639        modifiers: [],
1640        strategy: "absolute"
1641      };
1642      function areValidElements() {
1643        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
1644          args[_key] = arguments[_key];
1645        }
1646        return !args.some(function(element) {
1647          return !(element && typeof element.getBoundingClientRect === "function");
1648        });
1649      }
1650      function popperGenerator(generatorOptions) {
1651        if (generatorOptions === void 0) {
1652          generatorOptions = {};
1653        }
1654        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;
1655        return function createPopper3(reference2, popper2, options) {
1656          if (options === void 0) {
1657            options = defaultOptions;
1658          }
1659          var state = {
1660            placement: "bottom",
1661            orderedModifiers: [],
1662            options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
1663            modifiersData: {},
1664            elements: {
1665              reference: reference2,
1666              popper: popper2
1667            },
1668            attributes: {},
1669            styles: {}
1670          };
1671          var effectCleanupFns = [];
1672          var isDestroyed = false;

1673          var instance = {
1674            state,
1675            setOptions: function setOptions(setOptionsAction) {
1676              var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
1677              cleanupModifierEffects();
1678              state.options = Object.assign({}, defaultOptions, state.options, options2);
1679              state.scrollParents = {
1680                reference: isElement2(reference2) ? listScrollParents(reference2) : reference2.contextElement ? listScrollParents(reference2.contextElement) : [],
1681                popper: listScrollParents(popper2)
1682              };
1683              var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers2, state.options.modifiers)));
1684              state.orderedModifiers = orderedModifiers.filter(function(m) {
1685                return m.enabled;
1686              });
1687              if (true) {
1688                var modifiers = uniqueBy([].concat(orderedModifiers, state.options.modifiers), function(_ref) {
1689                  var name = _ref.name;
1690                  return name;
1691                });
1692                validateModifiers(modifiers);
1693                if (getBasePlacement(state.options.placement) === auto) {
1694                  var flipModifier = state.orderedModifiers.find(function(_ref2) {
1695                    var name = _ref2.name;
1696                    return name === "flip";
1697                  });
1698                  if (!flipModifier) {
1699                    console.error(['Popper: "auto" placements require the "flip" modifier be', "present and enabled to work."].join(" "));
1700                  }
1701                }
1702                var _getComputedStyle = getComputedStyle2(popper2), marginTop = _getComputedStyle.marginTop, marginRight = _getComputedStyle.marginRight, marginBottom = _getComputedStyle.marginBottom, marginLeft = _getComputedStyle.marginLeft;
1703                if ([marginTop, marginRight, marginBottom, marginLeft].some(function(margin) {
1704                  return parseFloat(margin);
1705                })) {
1706                  console.warn(['Popper: CSS "margin" styles cannot be used to apply padding', "between the popper and its reference element or boundary.", "To replicate margin, use the `offset` modifier, as well as", "the `padding` option in the `preventOverflow` and `flip`", "modifiers."].join(" "));
1707                }
1708              }
1709              runModifierEffects();
1710              return instance.update();
1711            },
1712            // Sync update – it will always be executed, even if not necessary. This
1713            // is useful for low frequency updates where sync behavior simplifies the
1714            // logic.
1715            // For high frequency updates (e.g. `resize` and `scroll` events), always
1716            // prefer the async Popper#update method
1717            forceUpdate: function forceUpdate() {
1718              if (isDestroyed) {
1719                return;
1720              }
1721              var _state$elements = state.elements, reference3 = _state$elements.reference, popper3 = _state$elements.popper;
1722              if (!areValidElements(reference3, popper3)) {
1723                if (true) {
1724                  console.error(INVALID_ELEMENT_ERROR);
1725                }
1726                return;
1727              }
1728              state.rects = {
1729                reference: getCompositeRect(reference3, getOffsetParent(popper3), state.options.strategy === "fixed"),
1730                popper: getLayoutRect(popper3)
1731              };
1732              state.reset = false;
1733              state.placement = state.options.placement;
1734              state.orderedModifiers.forEach(function(modifier) {
1735                return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
1736              });
1737              var __debug_loops__ = 0;
1738              for (var index = 0; index < state.orderedModifiers.length; index++) {
1739                if (true) {
1740                  __debug_loops__ += 1;
1741                  if (__debug_loops__ > 100) {
1742                    console.error(INFINITE_LOOP_ERROR);
1743                    break;
1744                  }
1745                }
1746                if (state.reset === true) {
1747                  state.reset = false;

1748                  index = -1;
1749                  continue;
1750                }
1751                var _state$orderedModifie = state.orderedModifiers[index], fn = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name;
1752                if (typeof fn === "function") {
1753                  state = fn({
1754                    state,
1755                    options: _options,
1756                    name,
1757                    instance
1758                  }) || state;
1759                }
1760              }
1761            },
1762            // Async and optimistically optimized update – it will not be executed if
1763            // not necessary (debounced to run at most once-per-tick)
1764            update: debounce(function() {
1765              return new Promise(function(resolve) {
1766                instance.forceUpdate();
1767                resolve(state);
1768              });
1769            }),
1770            destroy: function destroy() {
1771              cleanupModifierEffects();
1772              isDestroyed = true;
1773            }
1774          };
1775          if (!areValidElements(reference2, popper2)) {
1776            if (true) {
1777              console.error(INVALID_ELEMENT_ERROR);
1778            }
1779            return instance;
1780          }
1781          instance.setOptions(options).then(function(state2) {
1782            if (!isDestroyed && options.onFirstUpdate) {
1783              options.onFirstUpdate(state2);
1784            }
1785          });
1786          function runModifierEffects() {
1787            state.orderedModifiers.forEach(function(_ref3) {
1788              var name = _ref3.name, _ref3$options = _ref3.options, options2 = _ref3$options === void 0 ? {} : _ref3$options, effect2 = _ref3.effect;
1789              if (typeof effect2 === "function") {
1790                var cleanupFn = effect2({
1791                  state,
1792                  name,
1793                  instance,
1794                  options: options2
1795                });
1796                var noopFn = function noopFn2() {
1797                };
1798                effectCleanupFns.push(cleanupFn || noopFn);
1799              }
1800            });
1801          }
1802          function cleanupModifierEffects() {
1803            effectCleanupFns.forEach(function(fn) {
1804              return fn();
1805            });
1806            effectCleanupFns = [];
1807          }
1808          return instance;
1809        };
1810      }
1811      var passive = {
1812        passive: true
1813      };
1814      function effect$2(_ref) {
1815        var state = _ref.state, instance = _ref.instance, options = _ref.options;
1816        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;
1817        var window2 = getWindow(state.elements.popper);
1818        var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
1819        if (scroll) {
1820          scrollParents.forEach(function(scrollParent) {
1821            scrollParent.addEventListener("scroll", instance.update, passive);
1822          });
1823        }
1824        if (resize) {
1825          window2.addEventListener("resize", instance.update, passive);
1826        }
1827        return function() {
1828          if (scroll) {
1829            scrollParents.forEach(function(scrollParent) {
1830              scrollParent.removeEventListener("scroll", instance.update, passive);
1831            });
1832          }
1833          if (resize) {
1834            window2.removeEventListener("resize", instance.update, passive);
1835          }
1836        };
1837      }
1838      var eventListeners = {
1839        name: "eventListeners",
1840        enabled: true,
1841        phase: "write",
1842        fn: function fn() {
1843        },
1844        effect: effect$2,
1845        data: {}
1846      };
1847      function popperOffsets(_ref) {
1848        var state = _ref.state, name = _ref.name;
1849        state.modifiersData[name] = computeOffsets({
1850          reference: state.rects.reference,
1851          element: state.rects.popper,
1852          strategy: "absolute",
1853          placement: state.placement
1854        });
1855      }
1856      var popperOffsets$1 = {
1857        name: "popperOffsets",
1858        enabled: true,
1859        phase: "read",
1860        fn: popperOffsets,
1861        data: {}
1862      };
1863      var unsetSides = {
1864        top: "auto",
1865        right: "auto",
1866        bottom: "auto",
1867        left: "auto"
1868      };
1869      function roundOffsetsByDPR(_ref) {
1870        var x = _ref.x, y = _ref.y;
1871        var win = window;
1872        var dpr = win.devicePixelRatio || 1;
1873        return {
1874          x: round(x * dpr) / dpr || 0,
1875          y: round(y * dpr) / dpr || 0
1876        };
1877      }
1878      function mapToStyles(_ref2) {
1879        var _Object$assign2;
1880        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;
1881        var _ref3 = roundOffsets === true ? roundOffsetsByDPR(offsets) : typeof roundOffsets === "function" ? roundOffsets(offsets) : offsets, _ref3$x = _ref3.x, x = _ref3$x === void 0 ? 0 : _ref3$x, _ref3$y = _ref3.y, y = _ref3$y === void 0 ? 0 : _ref3$y;
1882        var hasX = offsets.hasOwnProperty("x");
1883        var hasY = offsets.hasOwnProperty("y");
1884        var sideX = left;
1885        var sideY = top;
1886        var win = window;
1887        if (adaptive) {
1888          var offsetParent = getOffsetParent(popper2);
1889          var heightProp = "clientHeight";
1890          var widthProp = "clientWidth";

1975        Object.keys(state.elements).forEach(function(name) {
1976          var style = state.styles[name] || {};
1977          var attributes = state.attributes[name] || {};
1978          var element = state.elements[name];
1979          if (!isHTMLElement(element) || !getNodeName(element)) {
1980            return;
1981          }
1982          Object.assign(element.style, style);
1983          Object.keys(attributes).forEach(function(name2) {
1984            var value = attributes[name2];
1985            if (value === false) {
1986              element.removeAttribute(name2);
1987            } else {
1988              element.setAttribute(name2, value === true ? "" : value);
1989            }
1990          });
1991        });
1992      }
1993      function effect$1(_ref2) {
1994        var state = _ref2.state;
1995        var initialStyles = {
1996          popper: {
1997            position: state.options.strategy,
1998            left: "0",
1999            top: "0",
2000            margin: "0"
2001          },
2002          arrow: {
2003            position: "absolute"
2004          },
2005          reference: {}
2006        };
2007        Object.assign(state.elements.popper.style, initialStyles.popper);
2008        state.styles = initialStyles;
2009        if (state.elements.arrow) {
2010          Object.assign(state.elements.arrow.style, initialStyles.arrow);
2011        }
2012        return function() {
2013          Object.keys(state.elements).forEach(function(name) {
2014            var element = state.elements[name];
2015            var attributes = state.attributes[name] || {};
2016            var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]);
2017            var style = styleProperties.reduce(function(style2, property) {
2018              style2[property] = "";
2019              return style2;
2020            }, {});
2021            if (!isHTMLElement(element) || !getNodeName(element)) {
2022              return;
2023            }
2024            Object.assign(element.style, style);
2025            Object.keys(attributes).forEach(function(attribute) {
2026              element.removeAttribute(attribute);
2027            });
2028          });
2029        };
2030      }
2031      var applyStyles$1 = {
2032        name: "applyStyles",
2033        enabled: true,
2034        phase: "write",
2035        fn: applyStyles,
2036        effect: effect$1,
2037        requires: ["computeStyles"]
2038      };
2039      function distanceAndSkiddingToXY(placement, rects, offset2) {
2040        var basePlacement = getBasePlacement(placement);
2041        var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
2042        var _ref = typeof offset2 === "function" ? offset2(Object.assign({}, rects, {
2043          placement
2044        })) : offset2, skidding = _ref[0], distance = _ref[1];
2045        skidding = skidding || 0;
2046        distance = (distance || 0) * invertDistance;
2047        return [left, right].indexOf(basePlacement) >= 0 ? {
2048          x: distance,
2049          y: skidding
2050        } : {
2051          x: skidding,
2052          y: distance
2053        };
2054      }
2055      function offset(_ref2) {
2056        var state = _ref2.state, options = _ref2.options, name = _ref2.name;
2057        var _options$offset = options.offset, offset2 = _options$offset === void 0 ? [0, 0] : _options$offset;
2058        var data = placements.reduce(function(acc, placement) {
2059          acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset2);
2060          return acc;
2061        }, {});
2062        var _data$state$placement = data[state.placement], x = _data$state$placement.x, y = _data$state$placement.y;
2063        if (state.modifiersData.popperOffsets != null) {
2064          state.modifiersData.popperOffsets.x += x;
2065          state.modifiersData.popperOffsets.y += y;
2066        }
2067        state.modifiersData[name] = data;
2068      }
2069      var offset$1 = {
2070        name: "offset",
2071        enabled: true,
2072        phase: "main",
2073        requires: ["popperOffsets"],
2074        fn: offset
2075      };
2076      var hash$1 = {
2077        left: "right",
2078        right: "left",
2079        bottom: "top",
2080        top: "bottom"
2081      };
2082      function getOppositePlacement(placement) {
2083        return placement.replace(/left|right|bottom|top/g, function(matched) {
2084          return hash$1[matched];
2085        });
2086      }
2087      var hash = {
2088        start: "end",
2089        end: "start"
2090      };
2091      function getOppositeVariationPlacement(placement) {
2092        return placement.replace(/start|end/g, function(matched) {
2093          return hash[matched];
2094        });
2095      }
2096      function computeAutoPlacement(state, options) {
2097        if (options === void 0) {
2098          options = {};
2099        }
2100        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;
2101        var variation = getVariation(placement);
2102        var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function(placement2) {
2103          return getVariation(placement2) === variation;
2104        }) : basePlacements;
2105        var allowedPlacements = placements$1.filter(function(placement2) {
2106          return allowedAutoPlacements.indexOf(placement2) >= 0;
2107        });
2108        if (allowedPlacements.length === 0) {
2109          allowedPlacements = placements$1;
2110          if (true) {
2111            console.error(["Popper: The `allowedAutoPlacements` option did not allow any", "placements. Ensure the `placement` option matches the variation", "of the allowed placements.", 'For example, "auto" cannot be used to allow "bottom-start".', 'Use "auto-start" instead.'].join(" "));
2112          }
2113        }
2114        var overflows = allowedPlacements.reduce(function(acc, placement2) {
2115          acc[placement2] = detectOverflow(state, {
2116            placement: placement2,
2117            boundary,
2118            rootBoundary,
2119            padding
2120          })[getBasePlacement(placement2)];
2121          return acc;
2122        }, {});
2123        return Object.keys(overflows).sort(function(a, b) {
2124          return overflows[a] - overflows[b];
2125        });
2126      }
2127      function getExpandedFallbackPlacements(placement) {
2128        if (getBasePlacement(placement) === auto) {
2129          return [];
2130        }
2131        var oppositePlacement = getOppositePlacement(placement);
2132        return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
2133      }
2134      function flip(_ref) {
2135        var state = _ref.state, options = _ref.options, name = _ref.name;
2136        if (state.modifiersData[name]._skip) {
2137          return;
2138        }
2139        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;
2140        var preferredPlacement = state.options.placement;
2141        var basePlacement = getBasePlacement(preferredPlacement);
2142        var isBasePlacement = basePlacement === preferredPlacement;
2143        var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
2144        var placements2 = [preferredPlacement].concat(fallbackPlacements).reduce(function(acc, placement2) {
2145          return acc.concat(getBasePlacement(placement2) === auto ? computeAutoPlacement(state, {
2146            placement: placement2,
2147            boundary,
2148            rootBoundary,
2149            padding,
2150            flipVariations,
2151            allowedAutoPlacements
2152          }) : placement2);
2153        }, []);
2154        var referenceRect = state.rects.reference;
2155        var popperRect = state.rects.popper;
2156        var checksMap = /* @__PURE__ */ new Map();
2157        var makeFallbackChecks = true;
2158        var firstFittingPlacement = placements2[0];
2159        for (var i = 0; i < placements2.length; i++) {
2160          var placement = placements2[i];
2161          var _basePlacement = getBasePlacement(placement);
2162          var isStartVariation = getVariation(placement) === start;
2163          var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;
2164          var len = isVertical ? "width" : "height";
2165          var overflow = detectOverflow(state, {
2166            placement,
2167            boundary,
2168            rootBoundary,
2169            altBoundary,
2170            padding
2171          });
2172          var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
2173          if (referenceRect[len] > popperRect[len]) {
2174            mainVariationSide = getOppositePlacement(mainVariationSide);
2175          }
2176          var altVariationSide = getOppositePlacement(mainVariationSide);
2177          var checks = [];
2178          if (checkMainAxis) {
2179            checks.push(overflow[_basePlacement] <= 0);
2180          }
2181          if (checkAltAxis) {
2182            checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
2183          }
2184          if (checks.every(function(check) {
2185            return check;
2186          })) {
2187            firstFittingPlacement = placement;
2188            makeFallbackChecks = false;

2189            break;
2190          }
2191          checksMap.set(placement, checks);
2192        }
2193        if (makeFallbackChecks) {
2194          var numberOfChecks = flipVariations ? 3 : 1;
2195          var _loop = function _loop2(_i2) {
2196            var fittingPlacement = placements2.find(function(placement2) {
2197              var checks2 = checksMap.get(placement2);
2198              if (checks2) {
2199                return checks2.slice(0, _i2).every(function(check) {
2200                  return check;
2201                });
2202              }
2203            });
2204            if (fittingPlacement) {
2205              firstFittingPlacement = fittingPlacement;
2206              return "break";
2207            }
2208          };
2209          for (var _i = numberOfChecks; _i > 0; _i--) {
2210            var _ret = _loop(_i);
2211            if (_ret === "break") break;
2212          }
2213        }
2214        if (state.placement !== firstFittingPlacement) {
2215          state.modifiersData[name]._skip = true;
2216          state.placement = firstFittingPlacement;
2217          state.reset = true;
2218        }
2219      }
2220      var flip$1 = {
2221        name: "flip",
2222        enabled: true,
2223        phase: "main",
2224        fn: flip,
2225        requiresIfExists: ["offset"],
2226        data: {
2227          _skip: false
2228        }
2229      };
2230      function getAltAxis(axis) {
2231        return axis === "x" ? "y" : "x";
2232      }
2233      function within(min$1, value, max$1) {
2234        return max(min$1, min(value, max$1));
2235      }
2236      function withinMaxClamp(min2, value, max2) {
2237        var v = within(min2, value, max2);
2238        return v > max2 ? max2 : v;
2239      }
2240      function preventOverflow(_ref) {
2241        var state = _ref.state, options = _ref.options, name = _ref.name;
2242        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;
2243        var overflow = detectOverflow(state, {
2244          boundary,
2245          rootBoundary,
2246          padding,
2247          altBoundary
2248        });
2249        var basePlacement = getBasePlacement(state.placement);
2250        var variation = getVariation(state.placement);
2251        var isBasePlacement = !variation;
2252        var mainAxis = getMainAxisFromPlacement(basePlacement);
2253        var altAxis = getAltAxis(mainAxis);
2254        var popperOffsets2 = state.modifiersData.popperOffsets;
2255        var referenceRect = state.rects.reference;
2256        var popperRect = state.rects.popper;
2257        var tetherOffsetValue = typeof tetherOffset === "function" ? tetherOffset(Object.assign({}, state.rects, {
2258          placement: state.placement
2259        })) : tetherOffset;
2260        var normalizedTetherOffsetValue = typeof tetherOffsetValue === "number" ? {
2261          mainAxis: tetherOffsetValue,
2262          altAxis: tetherOffsetValue
2263        } : Object.assign({
2264          mainAxis: 0,
2265          altAxis: 0
2266        }, tetherOffsetValue);
2267        var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
2268        var data = {
2269          x: 0,
2270          y: 0
2271        };
2272        if (!popperOffsets2) {
2273          return;
2274        }
2275        if (checkMainAxis) {
2276          var _offsetModifierState$;
2277          var mainSide = mainAxis === "y" ? top : left;
2278          var altSide = mainAxis === "y" ? bottom : right;
2279          var len = mainAxis === "y" ? "height" : "width";
2280          var offset2 = popperOffsets2[mainAxis];
2281          var min$1 = offset2 + overflow[mainSide];
2282          var max$1 = offset2 - overflow[altSide];
2283          var additive = tether ? -popperRect[len] / 2 : 0;
2284          var minLen = variation === start ? referenceRect[len] : popperRect[len];
2285          var maxLen = variation === start ? -popperRect[len] : -referenceRect[len];
2286          var arrowElement = state.elements.arrow;
2287          var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
2288            width: 0,
2289            height: 0
2290          };
2291          var arrowPaddingObject = state.modifiersData["arrow#persistent"] ? state.modifiersData["arrow#persistent"].padding : getFreshSideObject();
2292          var arrowPaddingMin = arrowPaddingObject[mainSide];
2293          var arrowPaddingMax = arrowPaddingObject[altSide];
2294          var arrowLen = within(0, referenceRect[len], arrowRect[len]);
2295          var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
2296          var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
2297          var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
2298          var clientOffset = arrowOffsetParent ? mainAxis === "y" ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
2299          var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
2300          var tetherMin = offset2 + minOffset - offsetModifierValue - clientOffset;
2301          var tetherMax = offset2 + maxOffset - offsetModifierValue;
2302          var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset2, tether ? max(max$1, tetherMax) : max$1);
2303          popperOffsets2[mainAxis] = preventedOffset;
2304          data[mainAxis] = preventedOffset - offset2;
2305        }
2306        if (checkAltAxis) {
2307          var _offsetModifierState$2;
2308          var _mainSide = mainAxis === "x" ? top : left;
2309          var _altSide = mainAxis === "x" ? bottom : right;
2310          var _offset = popperOffsets2[altAxis];
2311          var _len = altAxis === "y" ? "height" : "width";
2312          var _min = _offset + overflow[_mainSide];
2313          var _max = _offset - overflow[_altSide];
2314          var isOriginSide = [top, left].indexOf(basePlacement) !== -1;
2315          var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
2316          var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
2317          var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
2318          var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
2319          popperOffsets2[altAxis] = _preventedOffset;
2320          data[altAxis] = _preventedOffset - _offset;
2321        }
2322        state.modifiersData[name] = data;
2323      }
2324      var preventOverflow$1 = {
2325        name: "preventOverflow",
2326        enabled: true,
2327        phase: "main",
2328        fn: preventOverflow,
2329        requiresIfExists: ["offset"]
2330      };
2331      var toPaddingObject = function toPaddingObject2(padding, state) {
2332        padding = typeof padding === "function" ? padding(Object.assign({}, state.rects, {
2333          placement: state.placement
2334        })) : padding;
2335        return mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
2336      };
2337      function arrow(_ref) {
2338        var _state$modifiersData$;
2339        var state = _ref.state, name = _ref.name, options = _ref.options;
2340        var arrowElement = state.elements.arrow;
2341        var popperOffsets2 = state.modifiersData.popperOffsets;
2342        var basePlacement = getBasePlacement(state.placement);
2343        var axis = getMainAxisFromPlacement(basePlacement);
2344        var isVertical = [left, right].indexOf(basePlacement) >= 0;
2345        var len = isVertical ? "height" : "width";
2346        if (!arrowElement || !popperOffsets2) {
2347          return;
2348        }
2349        var paddingObject = toPaddingObject(options.padding, state);
2350        var arrowRect = getLayoutRect(arrowElement);
2351        var minProp = axis === "y" ? top : left;
2352        var maxProp = axis === "y" ? bottom : right;
2353        var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets2[axis] - state.rects.popper[len];
2354        var startDiff = popperOffsets2[axis] - state.rects.reference[axis];
2355        var arrowOffsetParent = getOffsetParent(arrowElement);
2356        var clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
2357        var centerToReference = endDiff / 2 - startDiff / 2;
2358        var min2 = paddingObject[minProp];
2359        var max2 = clientSize - arrowRect[len] - paddingObject[maxPro

2359p];
2360        var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
2361        var offset2 = within(min2, center, max2);
2362        var axisProp = axis;
2363        state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset2, _state$modifiersData$.centerOffset = offset2 - center, _state$modifiersData$);
2364      }
2365      function effect(_ref2) {
2366        var state = _ref2.state, options = _ref2.options;
2367        var _options$element = options.element, arrowElement = _options$element === void 0 ? "[data-popper-arrow]" : _options$element;
2368        if (arrowElement == null) {
2369          return;
2370        }
2371        if (typeof arrowElement === "string") {
2372          arrowElement = state.elements.popper.querySelector(arrowElement);
2373          if (!arrowElement) {
2374            return;
2375          }
2376        }
2377        if (true) {
2378          if (!isHTMLElement(arrowElement)) {
2379            console.error(['Popper: "arrow" element must be an HTMLElement (not an SVGElement).', "To use an SVG arrow, wrap it in an HTMLElement that will be used as", "the arrow."].join(" "));
2380          }
2381        }
2382        if (!contains(state.elements.popper, arrowElement)) {
2383          if (true) {
2384            console.error(['Popper: "arrow" modifier\'s `element` must be a child of the popper', "element."].join(" "));
2385          }
2386          return;
2387        }
2388        state.elements.arrow = arrowElement;
2389      }
2390      var arrow$1 = {
2391        name: "arrow",
2392        enabled: true,
2393        phase: "main",
2394        fn: arrow,
2395        effect,
2396        requires: ["popperOffsets"],
2397        requiresIfExists: ["preventOverflow"]
2398      };
2399      function getSideOffsets(overflow, rect, preventedOffsets) {
2400        if (preventedOffsets === void 0) {
2401          preventedOffsets = {
2402            x: 0,
2403            y: 0
2404          };
2405        }
2406        return {
2407          top: overflow.top - rect.height - preventedOffsets.y,
2408          right: overflow.right - rect.width + preventedOffsets.x,
2409          bottom: overflow.bottom - rect.height + preventedOffsets.y,
2410          left: overflow.left - rect.width - preventedOffsets.x
2411        };
2412      }
2413      function isAnySideFullyClipped(overflow) {
2414        return [top, right, bottom, left].some(function(side) {
2415          return overflow[side] >= 0;
2416        });
2417      }
2418      function hide(_ref) {
2419        var state = _ref.state, name = _ref.name;
2420        var referenceRect = state.rects.reference;
2421        var popperRect = state.rects.popper;
2422        var preventedOffsets = state.modifiersData.preventOverflow;
2423        var referenceOverflow = detectOverflow(state, {
2424          elementContext: "reference"
2425        });
2426        var popperAltOverflow = detectOverflow(state, {
2427          altBoundary: true
2428        });
2429        var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
2430        var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
2431        var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
2432        var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
2433        state.modifiersData[name] = {
2434          referenceClippingOffsets,
2435          popperEscapeOffsets,
2436          isReferenceHidden,
2437          hasPopperEscaped
2438        };
2439        state.attributes.popper = Object.assign({}, state.attributes.popper, {
2440          "data-popper-reference-hidden": isReferenceHidden,
2441          "data-popper-escaped": hasPopperEscaped
2442        });
2443      }
2444      var hide$1 = {
2445        name: "hide",
2446        enabled: true,
2447        phase: "main",
2448        requiresIfExists: ["preventOverflow"],
2449        fn: hide
2450      };
2451      var defaultModifiers$1 = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1];
2452      var createPopper$1 = /* @__PURE__ */ popperGenerator({
2453        defaultModifiers: defaultModifiers$1
2454      });
2455      var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1];
2456      var createPopper2 = /* @__PURE__ */ popperGenerator({
2457        defaultModifiers
2458      });
2459      exports.applyStyles = applyStyles$1;
2460      exports.arrow = arrow$1;
2461      exports.computeStyles = computeStyles$1;
2462      exports.createPopper = createPopper2;
2463      exports.createPopperLite = createPopper$1;
2464      exports.defaultModifiers = defaultModifiers;
2465      exports.detectOverflow = detectOverflow;
2466      exports.eventListeners = eventListeners;
2467      exports.flip = flip$1;
2468      exports.hide = hide$1;
2469      exports.offset = offset$1;
2470      exports.popperGenerator = popperGenerator;
2471      exports.popperOffsets = popperOffsets$1;
2472      exports.preventOverflow = preventOverflow$1;
2473    }
2474  });
2475
2476  // ns-hugo-imp:/home/ubuntu/.cache/hugo_cache/modules/filecache/modules/pkg/mod/github.com/twbs/[email protected]+incompatible/js/src/dom/data.js
2477  var elementMap = /* @__PURE__ */ new Map();
2478  var data_default = {
2479    set(element, key, instance) {
2480      if (!elementMap.has(element)) {

2642    let called = false;
2643    const handler = ({ target }) => {
2644      if (target !== transitionElement) {
2645        return;
2646      }
2647      called = true;
2648      transitionElement.removeEventListener(TRANSITION_END, handler);
2649      execute(callback);
2650    };
2651    transitionElement.addEventListener(TRANSITION_END, handler);
2652    setTimeout(() => {
2653      if (!called) {
2654        triggerTransitionEnd(transitionElement);
2655      }
2656    }, emulatedDuration);
2657  };
2658  var getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
2659    const listLength = list.length;
2660    let index = list.indexOf(activeElement);
2661    if (index === -1) {
2662      return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];
2663    }
2664    index += shouldGetNext ? 1 : -1;
2665    if (isCycleAllowed) {
2666      index = (index + listLength) % listLength;
2667    }
2668    return list[Math.max(0, Math.min(index, listLength - 1))];
2669  };
2670
2671  // ns-hugo-imp:/home/ubuntu/.cache/hugo_cache/modules/filecache/modules/pkg/mod/github.com/twbs/[email protected]+incompatible/js/src/dom/event-handler.js
2672  var namespaceRegex = /[^.]*(?=\..*)\.|.*/;
2673  var stripNameRegex = /\..*/;
2674  var stripUidRegex = /::\d+$/;
2675  var eventRegistry = {};
2676  var uidEvent = 1;
2677  var customEvents = {
2678    mouseenter: "mouseover",
2679    mouseleave: "mouseout"
2680  };
2681  var nativeEvents = /* @__PURE__ */ new Set([
2682    "click",
2683    "dblclick",
2684    "mouseup",
2685    "mousedown",
2686    "contextmenu",
2687    "mousewheel",
2688    "DOMMouseScroll",
2689    "mouseover",
2690    "mouseout",
2691    "mousemove",
2692    "selectstart",
2693    "selectend",
2694    "keydown",
2695    "keypress",
2696    "keyup",
2697    "orientationchange",
2698    "touchstart",
2699    "touchmove",
2700    "touchend",
2701    "touchcancel",
2702    "pointerdown",
2703    "pointermove",
2704    "pointerup",
2705    "pointerleave",
2706    "pointercancel",
2707    "gesturestart",
2708    "gesturechange",
2709    "gestureend",
2710    "focus",
2711    "blur",
2712    "change",
2713    "reset",
2714    "select",
2715    "submit",
2716    "focusin",
2717    "focusout",
2718    "load",
2719    "unload",
2720    "beforeunload",
2721    "resize",
2722    "move",
2723    "DOMContentLoaded",
2724    "readystatechange",
2725    "error",
2726    "abort",
2727    "scroll"
2728  ]);
2729  function makeEventUid(element, uid) {
2730    return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
2731  }
2732  function getElementEvents(element) {
2733    const uid = makeEventUid(element);
2734    element.uidEvent = uid;
2735    eventRegistry[uid] = eventRegistry[uid] || {};
2736    return eventRegistry[uid];
2737  }
2738  function bootstrapHandler(element, fn) {
2739    return function handler(event) {
2740      hydrateObj(event, { delegateTarget: element });
2741      if (handler.oneOff) {
2742        EventHandler.off(element, event.type, fn);
2743      }
2744      return fn.apply(element, [event]);
2745    };
2746  }
2747  function bootstrapDelegationHandler(element, selector, fn) {
2748    return function handler(event) {
2749      const domElements = element.querySelectorAll(selector);
2750      for (let { target } = event; target && target !== this; target = target.parentNode) {
2751        for (const domElement of domElements) {
2752          if (domElement !== target) {
2753            continue;
2754          }
2755          hydrateObj(event, { delegateTarget: target });
2756          if (handler.oneOff) {
2757            EventHandler.off(element, event.type, selector, fn);
2758          }
2759          return fn.apply(target, [event]);
2760        }
2761      }
2762    };
2763  }
2764  function findHandler(events, callable, delegationSelector = null) {
2765    return Object.values(events).find((event) => event.callable === callable && event.delegationSelector === delegationSelector);
2766  }
2767  function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
2768    const isDelegated = typeof handler === "string";
2769    const callable = isDelegated ? delegationFunction : handler || delegationFunction;
2770    let typeEvent = getTypeEvent(originalTypeEvent);
2771    if (!nativeEvents.has(typeEvent)) {
2772      typeEvent = originalTypeEvent;
2773    }
2774    return [isDelegated, callable, typeEvent];
2775  }
2776  function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
2777    if (typeof originalTypeEvent !== "string" || !element) {
2778      return;
2779    }
2780    let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
2781    if (originalTypeEvent in customEvents) {
2782      const wrapFunction = (fn2) => {
2783        return function(event) {
2784          if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
2785            return fn2.call(this, event);
2786          }
2787        };
2788      };
2789      callable = wrapFunction(callable);
2790    }
2791    const events = getElementEvents(element);
2792    const handlers = events[typeEvent] || (events[typeEvent] = {});
2793    const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
2794    if (previousFunction) {
2795      previousFunction.oneOff = previousFunction.oneOff && oneOff;
2796      return;
2797    }
2798    const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ""));
2799    const fn = isDelegated ? bootstrapDelegationHandler(element, handler, callable) : bootstrapHandler(element, callable);
2800    fn.delegationSelector = isDelegated ? handler : null;
2801    fn.callable = callable;
2802    fn.oneOff = oneOff;
2803    fn.uidEvent = uid;
2804    handlers[uid] = fn;
2805    element.addEventListener(typeEvent, fn, isDelegated);
2806  }
2807  function removeHandler(element, events, typeEvent, handler, delegationSelector) {
2808    const fn = findHandler(events[typeEvent], handler, delegationSelector);
2809    if (!fn) {
2810      return;
2811    }
2812    element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
2813    delete events[typeEvent][fn.uidEvent];
2814  }
2815  function removeNamespacedHandlers(element, events, typeEvent, namespace) {
2816    const storeElementEvent = events[typeEvent] || {};
2817    for (const [handlerKey, event] of Object.entries(storeElementEvent)) {
2818      if (handlerKey.includes(namespace)) {
2819        removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
2820      }
2821    }
2822  }
2823  function getTypeEvent(event) {
2824    event = event.replace(stripNameRegex, "");
2825    return customEvents[event] || event;
2826  }
2827  var EventHandler = {
2828    on(element, event, handler, delegationFunction) {
2829      addHandler(element, event, handler, delegationFunction, false);
2830    },
2831    one(element, event, handler, delegationFunction) {
2832      addHandler(element, event, handler, delegationFunction, true);
2833    },
2834    off(element, originalTypeEvent, handler, delegationFunction) {
2835      if (typeof originalTypeEvent !== "string" || !element) {
2836        return;
2837      }
2838      const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
2839      const inNamespace = typeEvent !== originalTypeEvent;
2840      const events = getElementEvents(element);
2841      const storeElementEvent = events[typeEvent] || {};
2842      const isNamespace = originalTypeEvent.startsWith(".");
2843      if (typeof callable !== "undefined") {
2844        if (!Object.keys(storeElementEvent).length) {
2845          return;
2846        }
2847        removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
2848        return;
2849      }
2850      if (isNamespace) {
2851        for (const elementEvent of Object.keys(events)) {
2852          removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
2853        }
2854      }
2855      for (const [keyHandlers, event] of Object.entries(storeElementEvent)) {
2856        const handlerKey = keyHandlers.replace(stripUidRegex, "");
2857        if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
2858          removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
2859        }
2860      }
2861    },
2862    trigger(element, event, args) {
2863      if (typeof event !== "string" || !element) {
2864        return null;
2865      }
2866      const $ = getjQuery();
2867      const typeEvent = getTypeEvent(event);
2868      const inNamespace = event !== typeEvent;
2869      let jQueryEvent = null;
2870      let bubbles = true;
2871      let nativeDispatch = true;
2872      let defaultPrevented = false;
2873      if (inNamespace && $) {
2874        jQueryEvent = $.Event(event, args);
2875        $(element).trigger(jQueryEvent);
2876        bubbles = !jQueryEvent.isPropagationStopped();
2877        nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
2878        defaultPrevented = jQueryEvent.isDefaultPrevented();
2879      }
2880      const evt = hydrateObj(new Event(event, { bubbles, cancelable: true }), args);
2881      if (defaultPrevented) {
2882        evt.preventDefault();
2883      }
2884      if (nativeDispatch) {
2885        element.dispatchEvent(evt);
2886      }
2887      if (evt.defaultPrevented && jQueryEvent) {
2888        jQueryEvent.preventDefault();
2889      }
2890      return evt;
2891    }
2892  };
2893  function hydrateObj(obj, meta = {}) {
2894    for (const [key, value] of Object.entries(meta)) {
2895      try {
2896        obj[key] = value;
2897      } catch (e) {
2898        Object.defineProperty(obj, key, {
2899          configurable: true,
2900          get() {
2901            return value;
2902          }
2903        });
2904      }
2905    }
2906    return obj;
2907  }
2908  var event_handler_default = EventHandler;
2909
2910  // ns-hugo-imp:/home/ubuntu/.cache/hugo_cache/modules/filecache/modules/pkg/mod/github.com/twbs/[email protected]+incompatible/js/src/dom/manipulator.js
2911  function normalizeData(value) {
2912    if (value === "true") {
2913      return true;
2914    }
2915    if (value === "false") {
2916      return false;
2917    }
2918    if (value === Number(value).toString()) {
2919      return Number(value);
2920    }
2921    if (value === "" || value === "null") {
2922      return null;
2923    }
2924    if (typeof value !== "string") {
2925      return value;
2926    }
2927    try {
2928      return JSON.parse(decodeURIComponent(value));
2929    } catch (e) {
2930      return value;
2931    }
2932  }
2933  function normalizeDataKey(key) {
2934    return key.replace(/[A-Z]/g, (chr) => `-${chr.toLowerCase()}`);
2935  }
2936  var Manipulator = {
2937    setDataAttribute(element, key, value) {
2938      element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);
2939    },
2940    removeDataAttribute(element, key) {
2941      element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);
2942    },
2943    getDataAttributes(element) {
2944      if (!element) {
2945        return {};
2946      }
2947      const attributes = {};
2948      const bsKeys = Object.keys(element.dataset).filter((key) => key.startsWith("bs") && !key.startsWith("bsConfig"));
2949      for (const key of bsKeys) {
2950        let pureKey = key.replace(/^bs/, "");
2951        pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
2952        attributes[pureKey] = normalizeData(element.dataset[key]);
2953      }
2954      return attributes;
2955    },
2956    getDataAttribute(element, key) {
2957      return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
2958    }
2959  };
2960  var manipulator_default = Manipulator;
2961
2962  // ns-hugo-imp:/home/ubuntu/.cache/hugo_cache/modules/filecache/modules/pkg/mod/github.com/twbs/[email protected]+incompatible/js/src/util/config.js
2963  var Config = class {
2964    // Getters
2965    static get Default() {
2966      return {};
2967    }
2968    static get DefaultType() {
2969      return {};
2970    }
2971    static get NAME() {
2972      throw new Error('You have to implement the static method "NAME", for each component!');
2973    }
2974    _getConfig(config) {
2975      config = this._mergeConfigObj(config);
2976      config = this._configAfterMerge(config);
2977      this._typeCheckConfig(config);
2978      return config;
2979    }
2980    _configAfterMerge(config) {
2981      return config;
2982    }
2983    _mergeConfigObj(config, element) {
2984      const jsonConfig = isElement(element) ? manipulator_default.getDataAttribute(element, "config") : {};
2985      return {
2986        ...this.constructor.Default,
2987        ...typeof jsonConfig === "object" ? jsonConfig : {},
2988        ...isElement(element) ? manipulator_default.getDataAttributes(element) : {},
2989        ...typeof config === "object" ? config : {}
2990      };
2991    }
2992    _typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
2993      for (const [property, expectedTypes] of Object.entries(configTypes)) {
2994        const value = config[property];
2995        const valueType = isElement(value) ? "element" : toType(value);
2996        if (!new RegExp(expectedTypes).test(valueType)) {
2997          throw new TypeError(
2998            `${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`
2999          );
3000        }
3001      }
3002    }
3003  };
3004  var config_default = Config;
3005
3006  // ns-hugo-imp:/home/ubuntu/.cache/hugo_cache/modules/filecache/modules/pkg/mod/github.com/twbs/[email protected]+incompatible/js/src/base-component.js
3007  var VERSION = "5.3.2";
3008  var BaseComponent = class extends config_default {
3009    constructor(element, config) {
3010      super();
3011      element = getElement(element);
3012      if (!element) {
3013        return;
3014      }
3015      this._element = element;
3016      this._config = this._getConfig(config);
3017      data_default.set(this._element, this.constructor.DATA_KEY, this);
3018    }
3019    // Public
3020    dispose() {
3021      data_default.remove(this._element, this.constructor.DATA_KEY);
3022      event_handler_default.off(this._element, this.constructor.EVENT_KEY);