https://www.iceland.co.uk/app/plugins/wp-recipe-maker/dist/public-modern-split.js

711    for (let container of containers) {
712      temperatures.push(WPRecipeMaker.temperature.getData(container));
713    }
714    return temperatures;
715  },
716  getData(container) {
717    return {
718      container,
719      value: container.dataset.value,
720      unit: container.dataset.unit,
721      help: container.dataset.tooltip
722    };
723  }
724};
725
726/***/ }),
727
728/***/ 4181:
729/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
730
731"use strict";
732
733// EXPORTS
734__webpack_require__.d(__webpack_exports__, {
735  Ay: () => (/* binding */ tippy_esm),
736  DX: () => (/* binding */ inlinePositioning)
737});
738
739// UNUSED EXPORTS: animateFill, createSingleton, delegate, followCursor, hideAll, roundArrow, sticky
740
741;// ./node_modules/@popperjs/core/lib/dom-utils/getWindow.js
742function getWindow(node) {
743  if (node == null) {
744    return window;
745  }
746
747  if (node.toString() !== '[object Window]') {
748    var ownerDocument = node.ownerDocument;
749    return ownerDocument ? ownerDocument.defaultView || window : window;
750  }
751
752  return node;
753}
754;// ./node_modules/@popperjs/core/lib/dom-utils/instanceOf.js
755
756
757function isElement(node) {
758  var OwnElement = getWindow(node).Element;
759  return node instanceof OwnElement || node instanceof Element;
760}
761
762function isHTMLElement(node) {
763  var OwnElement = getWindow(node).HTMLElement;
764  return node instanceof OwnElement || node instanceof HTMLElement;
765}
766
767function isShadowRoot(node) {
768  // IE 11 has no ShadowRoot
769  if (typeof ShadowRoot === 'undefined') {
770    return false;
771  }
772
773  var OwnElement = getWindow(node).ShadowRoot;
774  return node instanceof OwnElement || node instanceof ShadowRoot;
775}
776
777
778;// ./node_modules/@popperjs/core/lib/utils/math.js
779var math_max = Math.max;
780var math_min = Math.min;
781var round = Math.round;
782;// ./node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js
783
784
785function getBoundingClientRect(element, includeScale) {
786  if (includeScale === void 0) {
787    includeScale = false;
788  }
789
790  var rect = element.getBoundingClientRect();
791  var scaleX = 1;
792  var scaleY = 1;
793
794  if (isHTMLElement(element) && includeScale) {
795    var offsetHeight = element.offsetHeight;
796    var offsetWidth = element.offsetWidth; // Do not attempt to divide by 0, otherwise we get `Infinity` as scale
797    // Fallback to 1 in case both values are `0`
798
799    if (offsetWidth > 0) {
800      scaleX = round(rect.width) / offsetWidth || 1;
801    }
802
803    if (offsetHeight > 0) {
804      scaleY = round(rect.height) / offsetHeight || 1;
805    }
806  }
807
808  return {
809    width: rect.width / scaleX,
810    height: rect.height / scaleY,
811    top: rect.top / scaleY,
812    right: rect.right / scaleX,
813    bottom: rect.bottom / scaleY,
814    left: rect.left / scaleX,
815    x: rect.left / scaleX,
816    y: rect.top / scaleY
817  };
818}
819;// ./node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js
820
821function getWindowScroll(node) {
822  var win = getWindow(node);
823  var scrollLeft = win.pageXOffset;
824  var scrollTop = win.pageYOffset;
825  return {
826    scrollLeft: scrollLeft,
827    scrollTop: scrollTop
828  };
829}
830;// ./node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js
831function getHTMLElementScroll(element) {
832  return {
833    scrollLeft: element.scrollLeft,
834    scrollTop: element.scrollTop
835  };
836}
837;// ./node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js
838
839
840
841
842function getNodeScroll(node) {
843  if (node === getWindow(node) || !isHTMLElement(node)) {
844    return getWindowScroll(node);
845  } else {
846    return getHTMLElementScroll(node);
847  }
848}
849;// ./node_modules/@popperjs/core/lib/dom-utils/getNodeName.js
850function getNodeName(element) {
851  return element ? (element.nodeName || '').toLowerCase() : null;
852}
853;// ./node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js
854
855function getDocumentElement(element) {
856  // $FlowFixMe[incompatible-return]: assume body is always available
857  return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
858  element.document) || window.document).documentElement;
859}
860;// ./node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js
861
862
863
864function getWindowScrollBarX(element) {
865  // If <html> has a CSS width greater than the viewport, then this will be
866  // incorrect for RTL.
867  // Popper 1 is broken in this case and never had a bug report so let's assume
868  // it's not an issue. I don't think anyone ever specifies width on <html>
869  // anyway.
870  // Browsers where the left scrollbar doesn't cause an issue report `0` for
871  // this (e.g. Edge 2019, IE11, Safari)
872  return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
873}
874;// ./node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js
875
876function getComputedStyle(element) {
877  return getWindow(element).getComputedStyle(element);
878}
879;// ./node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js
880
881function isScrollParent(element) {
882  // Firefox wants us to check `-x` and `-y` variations as well
883  var _getComputedStyle = getComputedStyle(element),
884      overflow = _getComputedStyle.overflow,
885      overflowX = _getComputedStyle.overflowX,
886      overflowY = _getComputedStyle.overflowY;
887
888  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
889}
890;// ./node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js
891
892
893
894
895
896
897
898
899
900function isElementScaled(element) {
901  var rect = element.getBoundingClientRect();
902  var scaleX = round(rect.width) / element.offsetWidth || 1;
903  var scaleY = round(rect.height) / element.offsetHeight || 1;
904  return scaleX !== 1 || scaleY !== 1;
905} // Returns the composite rect of an element relative to its offsetParent.
906// Composite means it takes into account transforms as well as layout.
907
908
909function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
910  if (isFixed === void 0) {
911    isFixed = false;
912  }
913
914  var isOffsetParentAnElement = isHTMLElement(offsetParent);
915  var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
916  var documentElement = getDocumentElement(offsetParent);
917  var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled);
918  var scroll = {
919    scrollLeft: 0,
920    scrollTop: 0
921  };
922  var offsets = {
923    x: 0,
924    y: 0
925  };
926
927  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
928    if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
929    isScrollParent(documentElement)) {
930      scroll = getNodeScroll(offsetParent);
931    }
932
933    if (isHTMLElement(offsetParent)) {
934      offsets = getBoundingClientRect(offsetParent, true);
935      offsets.x += offsetParent.clientLeft;
936      offsets.y += offsetParent.clientTop;
937    } else if (documentElement) {
938      offsets.x = getWindowScrollBarX(documentElement);
939    }
940  }
941
942  return {
943    x: rect.left + scroll.scrollLeft - offsets.x,
944    y: rect.top + scroll.scrollTop - offsets.y,
945    width: rect.width,
946    height: rect.height
947  };
948}
949;// ./node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js
950 // Returns the layout rect of an element relative to its offsetParent. Layout
951// means it doesn't take into account transforms.
952
953function getLayoutRect(element) {
954  var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.
955  // Fixes https://github.com/popperjs/popper-core/issues/1223
956
957  var width = element.offsetWidth;
958  var height = element.offsetHeight;
959
960  if (Math.abs(clientRect.width - width) <= 1) {
961    width = clientRect.width;
962  }
963
964  if (Math.abs(clientRect.height - height) <= 1) {
965    height = clientRect.height;
966  }
967
968  return {
969    x: element.offsetLeft,
970    y: element.offsetTop,
971    width: width,
972    height: height
973  };
974}
975;// ./node_modules/@popperjs/core/lib/dom-utils/getParentNode.js
976
977
978
979function getParentNode(element) {
980  if (getNodeName(element) === 'html') {
981    return element;
982  }
983
984  return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
985    // $FlowFixMe[incompatible-return]
986    // $FlowFixMe[prop-missing]
987    element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
988    element.parentNode || ( // DOM Element detected
989    isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
990    // $FlowFixMe[incompatible-call]: HTMLElement is a Node
991    getDocumentElement(element) // fallback
992
993  );
994}
995;// ./node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js
996
997
998
999
1000function getScrollParent(node) {
1001  if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
1002    // $FlowFixMe[incompatible-return]: assume body is always available
1003    return node.ownerDocument.body;
1004  }
1005
1006  if (isHTMLElement(node) && isScrollParent(node)) {
1007    return node;
1008  }
1009
1010  return getScrollParent(getParentNode(node));
1011}
1012;// ./node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js
1013
1014
1015
1016
1017/*
1018given a DOM element, return the list of all scroll parents, up the list of ancesors
1019until we get to the top window object. This list is what we attach scroll listeners
1020to, because if any of these parent elements scroll, we'll need to re-calculate the
1021reference element's position.
1022*/
1023
1024function listScrollParents(element, list) {
1025  var _element$ownerDocumen;
1026
1027  if (list === void 0) {
1028    list = [];
1029  }
1030
1031  var scrollParent = getScrollParent(element);
1032  var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
1033  var win = getWindow(scrollParent);
1034  var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
1035  var updatedList = list.concat(target);
1036  return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
1037  updatedList.concat(listScrollParents(getParentNode(target)));
1038}
1039;// ./node_modules/@popperjs/core/lib/dom-utils/isTableElement.js
1040
1041function isTableElement(element) {
1042  return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
1043}
1044;

1044// ./node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js
1045
1046
1047
1048
1049
1050
1051
1052function getTrueOffsetParent(element) {
1053  if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
1054  getComputedStyle(element).position === 'fixed') {
1055    return null;
1056  }
1057
1058  return element.offsetParent;
1059} // `.offsetParent` reports `null` for fixed elements, while absolute elements
1060// return the containing block
1061
1062
1063function getContainingBlock(element) {
1064  var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') !== -1;
1065  var isIE = navigator.userAgent.indexOf('Trident') !== -1;
1066
1067  if (isIE && isHTMLElement(element)) {
1068    // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
1069    var elementCss = getComputedStyle(element);
1070
1071    if (elementCss.position === 'fixed') {
1072      return null;
1073    }
1074  }
1075
1076  var currentNode = getParentNode(element);
1077
1078  if (isShadowRoot(currentNode)) {
1079    currentNode = currentNode.host;
1080  }
1081
1082  while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
1083    var css = getComputedStyle(currentNode); // This is non-exhaustive but covers the most common CSS properties that
1084    // create a containing block.
1085    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
1086
1087    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') {
1088      return currentNode;
1089    } else {
1090      currentNode = currentNode.parentNode;
1091    }
1092  }
1093
1094  return null;
1095} // Gets the closest ancestor positioned element. Handles some edge cases,
1096// such as table ancestors and cross browser bugs.
1097
1098
1099function getOffsetParent(element) {
1100  var window = getWindow(element);
1101  var offsetParent = getTrueOffsetParent(element);
1102
1103  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {
1104    offsetParent = getTrueOffsetParent(offsetParent);
1105  }
1106
1107  if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static')) {
1108    return window;
1109  }
1110
1111  return offsetParent || getContainingBlock(element) || window;
1112}
1113;// ./node_modules/@popperjs/core/lib/enums.js
1114var enums_top = 'top';
1115var bottom = 'bottom';
1116var right = 'right';
1117var left = 'left';
1118var auto = 'auto';
1119var basePlacements = [enums_top, bottom, right, left];
1120var start = 'start';
1121var end = 'end';
1122var clippingParents = 'clippingParents';
1123var viewport = 'viewport';
1124var popper = 'popper';
1125var reference = 'reference';
1126var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {
1127  return acc.concat([placement + "-" + start, placement + "-" + end]);
1128}, []);
1129var enums_placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {
1130  return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
1131}, []); // modifiers that need to read the DOM
1132
1133var beforeRead = 'beforeRead';
1134var read = 'read';
1135var afterRead = 'afterRead'; // pure-logic modifiers
1136
1137var beforeMain = 'beforeMain';
1138var main = 'main';
1139var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)
1140
1141var beforeWrite = 'beforeWrite';
1142var write = 'write';
1143var afterWrite = 'afterWrite';
1144var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
1145;// ./node_modules/@popperjs/core/lib/utils/orderModifiers.js
1146 // source: https://stackoverflow.com/questions/49875255
1147
1148function order(modifiers) {
1149  var map = new Map();
1150  var visited = new Set();
1151  var result = [];
1152  modifiers.forEach(function (modifier) {
1153    map.set(modifier.name, modifier);
1154  }); // On visiting object, check for its dependencies and visit them recursively
1155
1156  function sort(modifier) {
1157    visited.add(modifier.name);
1158    var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);

1159    requires.forEach(function (dep) {
1160      if (!visited.has(dep)) {
1161        var depModifier = map.get(dep);
1162
1163        if (depModifier) {
1164          sort(depModifier);
1165        }
1166      }
1167    });
1168    result.push(modifier);
1169  }
1170
1171  modifiers.forEach(function (modifier) {
1172    if (!visited.has(modifier.name)) {
1173      // check for visited object
1174      sort(modifier);
1175    }
1176  });
1177  return result;
1178}
1179
1180function orderModifiers(modifiers) {
1181  // order based on dependencies
1182  var orderedModifiers = order(modifiers); // order based on phase
1183
1184  return modifierPhases.reduce(function (acc, phase) {
1185    return acc.concat(orderedModifiers.filter(function (modifier) {
1186      return modifier.phase === phase;
1187    }));
1188  }, []);
1189}
1190;// ./node_modules/@popperjs/core/lib/utils/debounce.js
1191function debounce(fn) {
1192  var pending;
1193  return function () {
1194    if (!pending) {
1195      pending = new Promise(function (resolve) {
1196        Promise.resolve().then(function () {
1197          pending = undefined;
1198          resolve(fn());
1199        });
1200      });
1201    }
1202
1203    return pending;
1204  };
1205}
1206;// ./node_modules/@popperjs/core/lib/utils/mergeByName.js
1207function mergeByName(modifiers) {
1208  var merged = modifiers.reduce(function (merged, current) {
1209    var existing = merged[current.name];
1210    merged[current.name] = existing ? Object.assign({}, existing, current, {
1211      options: Object.assign({}, existing.options, current.options),
1212      data: Object.assign({}, existing.data, current.data)
1213    }) : current;
1214    return merged;
1215  }, {}); // IE11 does not support Object.values
1216
1217  return Object.keys(merged).map(function (key) {
1218    return merged[key];
1219  });
1220}
1221;// ./node_modules/@popperjs/core/lib/createPopper.js
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236var INVALID_ELEMENT_ERROR = 'Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.';
1237var INFINITE_LOOP_ERROR = 'Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.';
1238var DEFAULT_OPTIONS = {
1239  placement: 'bottom',
1240  modifiers: [],
1241  strategy: 'absolute'
1242};
1243
1244function areValidElements() {
1245  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
1246    args[_key] = arguments[_key];
1247  }
1248
1249  return !args.some(function (element) {
1250    return !(element && typeof element.getBoundingClientRect === 'function');
1251  });
1252}
1253
1254function popperGenerator(generatorOptions) {
1255  if (generatorOptions === void 0) {
1256    generatorOptions = {};
1257  }
1258
1259  var _generatorOptions = generatorOptions,
1260      _generatorOptions$def = _generatorOptions.defaultModifiers,
1261      defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def,
1262      _generatorOptions$def2 = _generatorOptions.defaultOptions,
1263      defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
1264  return function createPopper(reference, popper, options) {
1265    if (options === void 0) {
1266      options = defaultOptions;
1267    }
1268
1269    var state = {
1270      placement: 'bottom',
1271      orderedModifiers: [],
1272      options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
1273      modifiersData: {},
1274      elements: {
1275        reference: reference,
1276        popper: popper
1277      },
1278      attributes: {},
1279      styles: {}
1280    };
1281    var effectCleanupFns = [];
1282    var isDestroyed = false;
1283    var instance = {
1284      state: state,
1285      setOptions: function setOptions(setOptionsAction) {
1286        var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction;
1287        cleanupModifierEffects();
1288        state.options = Object.assign({}, defaultOptions, state.options, options);
1289        state.scrollParents = {
1290          reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],
1291          popper: listScrollParents(popper)
1292        }; // Orders the modifiers based on their dependencies and `phase`
1293        // properties
1294
1295        var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers
1296
1297        state.orderedModifiers = orderedModifiers.filter(function (m) {
1298          return m.enabled;
1299        }); // Validate the provided modifiers so that the consumer will get warned
1300        // if one of the modifiers is invalid for any reason
1301
1302        if (false) { var _getComputedStyle, marginTop, marginRight, marginBottom, marginLeft, flipModifier, modifiers; }
1303
1304        runModifierEffects();
1305        return instance.update();
1306      },
1307      // Sync update – it will always be executed, even if not necessary. This
1308      // is useful for low frequency updates where sync behavior simplifies the
1309      // logic.
1310      // For high frequency updates (e.g. `resize` and `scroll` events), always
1311      // prefer the async Popper#update method
1312      forceUpdate: function forceUpdate() {
1313        if (isDestroyed) {
1314          return;
1315        }
1316
1317        var _state$elements = state.elements,
1318            reference = _state$elements.reference,
1319            popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements
1320        // anymore
1321
1322        if (!areValidElements(reference, popper)) {
1323          if (false) {}
1324
1325          return;
1326        } // Store the reference and popper rects to be read by modifiers
1327
1328
1329        state.rects = {
1330          reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'),
1331          popper: getLayoutRect(popper)
1332        }; // Modifiers have the ability to reset the current update cycle. The
1333        // most common use case for this is the `flip` modifier changing the
1334        // placement, which then needs to re-run all the modifiers, because the
1335        // logic was previously ran for the previous placement and is therefore
1336        // stale/incorrect
1337
1338        state.reset = false;
1339        state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier
1340        // is filled with the initial data specified by the modifier. This means
1341        // it doesn't persist and is fresh on each update.
1342        // To ensure persistent data, use `${name}#persistent`
1343
1344        state.orderedModifiers.forEach(function (modifier) {
1345          return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
1346        });
1347        var __debug_loops__ = 0;
1348
1349        for (var index = 0; index < state.orderedModifiers.length; index++) {
1350          if (false) {}
1351
1352          if (state.reset === true) {
1353            state.reset = false;
1354            index = -1;
1355            continue;
1356          }
1357
1358          var _state$orderedModifie = state.orderedModifiers[index],
1359              fn = _state$orderedModifie.fn,
1360              _state$orderedModifie2 = _state$orderedModifie.options,
1361              _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2,
1362              name = _state$orderedModifie.name;
1363
1364          if (typeof fn === 'function') {
1365            state = fn({
1366              state: state,
1367              options: _options,
1368              name: name,
1369              instance: instance
1370            }) || state;
1371          }
1372        }
1373      },
1374      // Async and optimistically optimized update – it will not be executed if
1375      // not necessary (debounced to run at most once-per-tick)
1376      update: debounce(function () {
1377        return new Promise(function (resolve) {
1378          instance.forceUpdate();
1379          resolve(state);
1380        });
1381      }),
1382      destroy: function destroy() {
1383        cleanupModifierEffects();
1384        isDestroyed = true;
1385      }
1386    };
1387
1388    if (!areValidElements(reference, popper)) {
1389      if (false) {}
1390
1391      return instance;
1392    }
1393
1394    instance.setOptions(options).then(function (state) {
1395      if (!isDestroyed && options.onFirstUpdate) {
1396        options.onFirstUpdate(state);
1397      }
1398    }); // Modifiers have the ability to execute arbitrary code before the first
1399    // update cycle runs. They will be executed in the same order as the update
1400    // cycle. This is useful when a modifier adds some persistent data that
1401    // other modifiers need to use, but the modifier is run after the dependent
1402    // one.
1403
1404    function runModifierEffects() {
1405      state.orderedModifiers.forEach(function (_ref3) {
1406        var name = _ref3.name,
1407            _ref3$options = _ref3.options,
1408            options = _ref3$options === void 0 ? {}

1408 : _ref3$options,
1409            effect = _ref3.effect;
1410
1411        if (typeof effect === 'function') {
1412          var cleanupFn = effect({
1413            state: state,
1414            name: name,
1415            instance: instance,
1416            options: options
1417          });
1418
1419          var noopFn = function noopFn() {};
1420
1421          effectCleanupFns.push(cleanupFn || noopFn);
1422        }
1423      });
1424    }
1425
1426    function cleanupModifierEffects() {
1427      effectCleanupFns.forEach(function (fn) {
1428        return fn();
1429      });
1430      effectCleanupFns = [];
1431    }
1432
1433    return instance;
1434  };
1435}
1436var createPopper = /*#__PURE__*/(/* unused pure expression or super */ null && (popperGenerator())); // eslint-disable-next-line import/no-unused-modules
1437
1438
1439;// ./node_modules/@popperjs/core/lib/modifiers/eventListeners.js
1440 // eslint-disable-next-line import/no-unused-modules
1441
1442var passive = {
1443  passive: true
1444};
1445
1446function effect(_ref) {
1447  var state = _ref.state,
1448      instance = _ref.instance,
1449      options = _ref.options;
1450  var _options$scroll = options.scroll,
1451      scroll = _options$scroll === void 0 ? true : _options$scroll,
1452      _options$resize = options.resize,
1453      resize = _options$resize === void 0 ? true : _options$resize;
1454  var window = getWindow(state.elements.popper);
1455  var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
1456
1457  if (scroll) {
1458    scrollParents.forEach(function (scrollParent) {
1459      scrollParent.addEventListener('scroll', instance.update, passive);
1460    });
1461  }
1462
1463  if (resize) {
1464    window.addEventListener('resize', instance.update, passive);
1465  }
1466
1467  return function () {
1468    if (scroll) {
1469      scrollParents.forEach(function (scrollParent) {
1470        scrollParent.removeEventListener('scroll', instance.update, passive);
1471      });
1472    }
1473
1474    if (resize) {
1475      window.removeEventListener('resize', instance.update, passive);
1476    }
1477  };
1478} // eslint-disable-next-line import/no-unused-modules
1479
1480
1481/* harmony default export */ const eventListeners = ({
1482  name: 'eventListeners',
1483  enabled: true,
1484  phase: 'write',
1485  fn: function fn() {},
1486  effect: effect,
1487  data: {}
1488});
1489;// ./node_modules/@popperjs/core/lib/utils/getBasePlacement.js
1490
1491function getBasePlacement(placement) {
1492  return placement.split('-')[0];
1493}
1494;// ./node_modules/@popperjs/core/lib/utils/getVariation.js
1495function getVariation(placement) {
1496  return placement.split('-')[1];
1497}
1498;// ./node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js
1499function getMainAxisFromPlacement(placement) {
1500  return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
1501}
1502;// ./node_modules/@popperjs/core/lib/utils/computeOffsets.js
1503
1504
1505
1506
1507function computeOffsets(_ref) {
1508  var reference = _ref.reference,
1509      element = _ref.element,
1510      placement = _ref.placement;
1511  var basePlacement = placement ? getBasePlacement(placement) : null;
1512  var variation = placement ? getVariation(placement) : null;
1513  var commonX = reference.x + reference.width / 2 - element.width / 2;
1514  var commonY = reference.y + reference.height / 2 - element.height / 2;
1515  var offsets;
1516
1517  switch (basePlacement) {
1518    case enums_top:
1519      offsets = {
1520        x: commonX,
1521        y: reference.y - element.height
1522      };
1523      break;
1524
1525    case bottom:
1526      offsets = {
1527        x: commonX,
1528        y: reference.y + reference.height
1529      };
1530      break;
1531
1532    case right:
1533      offsets = {
1534        x: reference.x + reference.width,
1535        y: commonY
1536      };
1537      break;
1538
1539    case left:
1540      offsets = {
1541        x: reference.x - element.width,
1542        y: commonY
1543      };
1544      break;
1545
1546    default:
1547      offsets = {
1548        x: reference.x,
1549        y: reference.y
1550      };
1551  }
1552
1553  var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
1554
1555  if (mainAxis != null) {
1556    var len = mainAxis === 'y' ? 'height' : 'width';
1557
1558    switch (variation) {
1559      case start:
1560        offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
1561        break;
1562
1563      case end:
1564        offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
1565        break;
1566
1567      default:
1568    }
1569  }
1570
1571  return offsets;
1572}
1573;// ./node_modules/@popperjs/core/lib/modifiers/popperOffsets.js
1574
1575
1576function popperOffsets(_ref) {
1577  var state = _ref.state,
1578      name = _ref.name;
1579  // Offsets are the actual position the popper needs to have to be
1580  // properly positioned near its reference element
1581  // This is the most basic placement, and will be adjusted by
1582  // the modifiers in the next step
1583  state.modifiersData[name] = computeOffsets({
1584    reference: state.rects.reference,
1585    element: state.rects.popper,
1586    strategy: 'absolute',
1587    placement: state.placement
1588  });
1589} // eslint-disable-next-line import/no-unused-modules
1590
1591
1592/* harmony default export */ const modifiers_popperOffsets = ({
1593  name: 'popperOffsets',
1594  enabled: true,
1595  phase: 'read',
1596  fn: popperOffsets,
1597  data: {}
1598});
1599;// ./node_modules/@popperjs/core/lib/modifiers/computeStyles.js
1600
1601
1602
1603
1604
1605
1606
1607 // eslint-disable-next-line import/no-unused-modules
1608
1609var unsetSides = {
1610  top: 'auto',
1611  right: 'auto',
1612  bottom: 'auto',
1613  left: 'auto'
1614}; // Round the offsets to the nearest suitable subpixel based on the DPR.
1615// Zooming can change the DPR, but it seems to report a value that will
1616// cleanly divide the values into the appropriate subpixels.
1617
1618function roundOffsetsByDPR(_ref) {
1619  var x = _ref.x,
1620      y = _ref.y;
1621  var win = window;
1622  var dpr = win.devicePixelRatio || 1;
1623  return {
1624    x: round(x * dpr) / dpr || 0,
1625    y: round(y * dpr) / dpr || 0
1626  };
1627}
1628
1629function mapToStyles(_ref2) {
1630  var _Object$assign2;
1631
1632  var popper = _ref2.popper,
1633      popperRect = _ref2.popperRect,
1634      placement = _ref2.placement,
1635      variation = _ref2.variation,
1636      offsets = _ref2.offsets,
1637      position = _ref2.position,
1638      gpuAcceleration = _ref2.gpuAcceleration,
1639      adaptive = _ref2.adaptive,
1640      roundOffsets = _ref2.roundOffsets,
1641      isFixed = _ref2.isFixed;
1642  var _offsets$x = offsets.x,
1643      x = _offsets$x === void 0 ? 0 : _offsets$x,
1644      _offsets$y = offsets.y,
1645      y = _offsets$y === void 0 ? 0 : _offsets$y;
1646
1647  var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({
1648    x: x,
1649    y: y
1650  }) : {
1651    x: x,
1652    y: y
1653  };
1654
1655  x = _ref3.x;
1656  y = _ref3.y;
1657  var hasX = offsets.hasOwnProperty('x');
1658  var hasY = offsets.hasOwnProperty('y');
1659  var sideX = left;
1660  var sideY = enums_top;
1661  var win = window;
1662
1663  if (adaptive) {
1664    var offsetParent = getOffsetParent(popper);
1665    var heightProp = 'clientHeight';
1666    var widthProp = 'clientWidth';
1667
1668    if (offsetParent === getWindow(popper)) {
1669      offsetParent = getDocumentElement(popper);
1670
1671      if (getComputedStyle(offsetParent).position !== 'static' && position === 'absolute') {
1672        heightProp = 'scrollHeight';
1673        widthProp = 'scrollWidth';
1674      }
1675    } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
1676
1677
1678    offsetParent = offsetParent;
1679
1680    if (placement === enums_top || (placement === left || placement === right) && variation === end) {
1681      sideY = bottom;
1682      var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing]
1683      offsetParent[heightProp];
1684      y -= offsetY - popperRect.height;
1685      y *= gpuAcceleration ? 1 : -1;
1686    }
1687
1688    if (placement === left || (placement === enums_top || placement === bottom) && variation === end) {
1689      sideX = right;
1690      var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing]
1691      offsetParent[widthProp];
1692      x -= offsetX - popperRect.width;
1693      x *= gpuAcceleration ? 1 : -1;
1694    }
1695  }
1696
1697  var commonStyles = Object.assign({
1698    position: position
1699  }, adaptive && unsetSides);
1700
1701  var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
1702    x: x,
1703    y: y
1704  }) : {
1705    x: x,
1706    y: y
1707  };
1708
1709  x = _ref4.x;
1710  y = _ref4.y;
1711
1712  if (gpuAcceleration) {
1713    var _Object$assign;
1714
1715    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));
1716  }
1717
1718  return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
1719}
1720
1721function computeStyles(_ref5) {
1722  var state = _ref5.state,
1723      options = _ref5.options;
1724  var _options$gpuAccelerat = options.gpuAcceleration,
1725      gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
1726      _options$adaptive = options.adaptive,
1727      adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
1728      _options$roundOffsets = options.roundOffsets,
1729      roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
1730
1731  if (false) { var transitionProperty; }
1732
1733  var commonStyles = {
1734    placement: getBasePlacement(state.placement),
1735    variation: getVariation(state.placement),
1736    popper: state.elements.popper,
1737    popperRect: state.rects.popper,
1738    gpuAcceleration: gpuAcceleration,
1739    isFixed: state.options.strategy === 'fixed'
1740  };
1741
1742  if (state.modifiersData.popperOffsets != null) {
1743    state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
1744      offsets: state.modifiersData.popperOffsets,
1745      position: state.options.strategy,
1746      adaptive: adaptive,
1747      roundOffsets: roundOffsets
1748    })));
1749  }
1750
1751  if (state.modifiersData.arrow != null) {
1752    state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
1753      offsets: state.modifiersData.arrow,
1754      position: 'absolute',
1755      adaptive: false,
1756      roundOffsets: roundOffsets
1757    })));
1758  }
1759
1760  state.attributes.popper = Object.assign({}, state.attributes.popper, {
1761    'data-popper-placement': state.placement
1762  });
1763} // eslint-disable-next-line import/no-unused-modules
1764
1765
1766/* harmony default export */ const modifiers_computeStyles = ({
1767  name: 'computeStyles',
1768  enabled: true,
1769  phase: 'beforeWrite',
1770  fn: computeStyles,
1771  data: {}
1772});
1773;// ./node_modules/@popperjs/core/lib/modifiers/applyStyles.js
1774
1775 // This modifier takes the styles prepared by the `computeStyles` modifier
1776// and applies them to the HTMLElements such as popper and arrow
1777
1778function applyStyles(_ref) {
1779  var state = _ref.state;
1780  Object.keys(state.elements).forEach(function (name) {
1781    var style = state.styles[name] || {};
1782    var attributes = state.attributes[name] || {};
1783    var element = state.elements[name]; // arrow is optional + virtual elements
1784
1785    if (!isHTMLElement(element) || !getNodeName(element)) {
1786      return;
1787    } // Flow doesn't support to extend this property, but it's the most
1788    // effective way to apply styles to an HTMLElement
1789    // $FlowFixMe[cannot-write]
1790
1791
1792    Object.assign(element.style, style);
1793    Object.keys(attributes).forEach(function (name) {
1794      var value = attributes[name];
1795
1796      if (value === false) {
1797        element.removeAttribute(name);
1798      } else {
1799        element.setAttribute(name, value === true ? '' : value);
1800      }
1801    });
1802  });
1803}
1804
1805function applyStyles_effect(_ref2) {
1806  var state = _ref2.state;
1807  var initialStyles = {
1808    popper: {
1809      position: state.options.strategy,
1810      left: '0',
1811      top: '0',
1812      margin: '0'
1813    },
1814    arrow: {
1815      position: 'absolute'
1816    },
1817    reference: {}
1818  };
1819  Object.assign(state.elements.popper.style, initialStyles.popper);
1820  state.styles = initialStyles;
1821
1822  if (state.elements.arrow) {
1823    Object.assign(state.elements.arrow.style, initialStyles.arrow);
1824  }
1825
1826  return function () {
1827    Object.keys(state.elements).forEach(function (name) {
1828      var element = state.elements[name];
1829      var attributes = state.attributes[name] || {};
1830      var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
1831
1832      var style = styleProperties.reduce(function (style, property) {
1833        style[property] = '';
1834        return style;
1835      }, {}); // arrow is optional + virtual elements
1836
1837      if (!isHTMLElement(element) || !getNodeName(element)) {
1838        return;
1839      }
1840
1841      Object.assign(element.style, style);
1842      Object.keys(attributes).forEach(function (attribute) {
1843        element.removeAttribute(attribute);
1844      });
1845    });
1846  };
1847} // eslint-disable-next-line import/no-unused-modules
1848
1849
1850/* harmony default export */ const modifiers_applyStyles = ({
1851  name: 'applyStyles',
1852  enabled: true,
1853  phase: 'write',
1854  fn: applyStyles,
1855  effect: applyStyles_effect,
1856  requires: ['computeStyles']
1857});
1858;// ./node_modules/@popperjs/core/lib/modifiers/offset.js
1859
1860 // eslint-disable-next-line import/no-unused-modules
1861
1862function distanceAndSkiddingToXY(placement, rects, offset) {
1863  var basePlacement = getBasePlacement(placement);
1864  var invertDistance = [left, enums_top].indexOf(basePlacement) >= 0 ? -1 : 1;
1865
1866  var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, {
1867    placement: placement
1868  })) : offset,
1869      skidding = _ref[0],
1870      distance = _ref[1];
1871
1872  skidding = skidding || 0;
1873  distance = (distance || 0) * invertDistance;
1874  return [left, right].indexOf(basePlacement) >= 0 ? {
1875    x: distance,
1876    y: skidding
1877  } : {
1878    x: skidding,
1879    y: distance
1880  };
1881}
1882
1883function offset(_ref2) {
1884  var state = _ref2.state,
1885      options = _ref2.options,
1886      name = _ref2.name;
1887  var _options$offset = options.offset,
1888      offset = _options$offset === void 0 ? [0, 0] : _options$offset;
1889  var data = enums_placements.reduce(function (acc, placement) {
1890    acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
1891    return acc;
1892  }, {});
1893  var _data$state$placement = data[state.placement],
1894      x = _data$state$placement.x,
1895      y = _data$state$placement.y;
1896
1897  if (state.modifiersData.popperOffsets != null) {
1898    state.modifiersData.popperOffsets.x += x;
1899    state.modifiersData.popperOffsets.y += y;
1900  }
1901
1902  state.modifiersData[name] = data;
1903} // eslint-disable-next-line import/no-unused-modules
1904
1905
1906/* harmony default export */ const modifiers_offset = ({
1907  name: 'offset',
1908  enabled: true,
1909  phase: 'main',
1910  requires: ['popperOffsets'],
1911  fn: offset
1912});
1913;// ./node_modules/@popperjs/core/lib/utils/getOppositePlacement.js
1914var hash = {
1915  left: 'right',
1916  right: 'left',
1917  bottom: 'top',
1918  top: 'bottom'
1919};
1920function getOppositePlacement(placement) {
1921  return placement.replace(/left|right|bottom|top/g, function (matched) {
1922    return hash[matched];
1923  });
1924}
1925;

1954    height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently)
1955    // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
1956    // errors due to floating point numbers, so we need to check precision.
1957    // Safari returns a number <= 0, usually < -1 when pinch-zoomed
1958    // Feature detection fails in mobile emulation mode in Chrome.
1959    // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
1960    // 0.001
1961    // Fallback here: "Not Safari" userAgent
1962
1963    if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
1964      x = visualViewport.offsetLeft;
1965      y = visualViewport.offsetTop;
1966    }
1967  }
1968
1969  return {
1970    width: width,
1971    height: height,
1972    x: x + getWindowScrollBarX(element),
1973    y: y
1974  };
1975}
1976;// ./node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js
1977
1978
1979
1980
1981 // Gets the entire size of the scrollable document area, even extending outside
1982// of the `<html>` and `<body>` rect bounds if horizontally scrollable
1983
1984function getDocumentRect(element) {
1985  var _element$ownerDocumen;
1986
1987  var html = getDocumentElement(element);
1988  var winScroll = getWindowScroll(element);
1989  var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
1990  var width = math_max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
1991  var height = math_max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
1992  var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
1993  var y = -winScroll.scrollTop;
1994
1995  if (getComputedStyle(body || html).direction === 'rtl') {
1996    x += math_max(html.clientWidth, body ? body.clientWidth : 0) - width;
1997  }
1998
1999  return {
2000    width: width,
2001    height: height,
2002    x: x,
2003    y: y
2004  };
2005}
2006;// ./node_modules/@popperjs/core/lib/dom-utils/contains.js
2007
2008function contains(parent, child) {
2009  var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method
2010
2011  if (parent.contains(child)) {
2012    return true;
2013  } // then fallback to custom implementation with Shadow DOM support
2014  else if (rootNode && isShadowRoot(rootNode)) {
2015      var next = child;
2016
2017      do {
2018        if (next && parent.isSameNode(next)) {
2019          return true;
2020        } // $FlowFixMe[prop-missing]: need a better way to handle this...
2021
2022
2023        next = next.parentNode || next.host;
2024      } while (next);
2025    } // Give up, the result is false
2026
2027
2028  return false;
2029}
2030;// ./node_modules/@popperjs/core/lib/utils/rectToClientRect.js
2031function rectToClientRect(rect) {
2032  return Object.assign({}, rect, {
2033    left: rect.x,
2034    top: rect.y,
2035    right: rect.x + rect.width,
2036    bottom: rect.y + rect.height
2037  });
2038}
2039;// ./node_modules/@popperjs/core/lib/dom-utils/getClippingRect.js
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055function getInnerBoundingClientRect(element) {
2056  var rect = getBoundingClientRect(element);
2057  rect.top = rect.top + element.clientTop;
2058  rect.left = rect.left + element.clientLeft;
2059  rect.bottom = rect.top + element.clientHeight;
2060  rect.right = rect.left + element.clientWidth;
2061  rect.width = element.clientWidth;
2062  rect.height = element.clientHeight;
2063  rect.x = rect.left;
2064  rect.y = rect.top;
2065  return rect;
2066}
2067
2068function getClientRectFromMixedType(element, clippingParent) {
2069  return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
2070} // A "clipping parent" is an overflowable container with the characteristic of
2071// clipping (or hiding) overflowing elements with a position different from
2072// `initial`
2073
2074
2075function getClippingParents(element) {
2076  var clippingParents = listScrollParents(getParentNode(element));
2077  var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle(element).position) >= 0;
2078  var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
2079
2080  if (!isElement(clipperElement)) {
2081    return [];
2082  } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414
2083
2084
2085  return clippingParents.filter(function (clippingParent) {
2086    return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body';
2087  });
2088} // Gets the maximum area that the element is visible in due to any number of
2089// clipping parents
2090
2091

2092function getClippingRect(element, boundary, rootBoundary) {
2093  var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
2094  var clippingParents = [].concat(mainClippingParents, [rootBoundary]);
2095  var firstClippingParent = clippingParents[0];
2096  var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {
2097    var rect = getClientRectFromMixedType(element, clippingParent);
2098    accRect.top = math_max(rect.top, accRect.top);
2099    accRect.right = math_min(rect.right, accRect.right);
2100    accRect.bottom = math_min(rect.bottom, accRect.bottom);
2101    accRect.left = math_max(rect.left, accRect.left);
2102    return accRect;
2103  }, getClientRectFromMixedType(element, firstClippingParent));
2104  clippingRect.width = clippingRect.right - clippingRect.left;
2105  clippingRect.height = clippingRect.bottom - clippingRect.top;
2106  clippingRect.x = clippingRect.left;
2107  clippingRect.y = clippingRect.top;
2108  return clippingRect;
2109}
2110;// ./node_modules/@popperjs/core/lib/utils/getFreshSideObject.js
2111function getFreshSideObject() {
2112  return {
2113    top: 0,
2114    right: 0,
2115    bottom: 0,
2116    left: 0
2117  };
2118}
2119;// ./node_modules/@popperjs/core/lib/utils/mergePaddingObject.js
2120
2121function mergePaddingObject(paddingObject) {
2122  return Object.assign({}, getFreshSideObject(), paddingObject);
2123}
2124;// ./node_modules/@popperjs/core/lib/utils/expandToHashMap.js
2125function expandToHashMap(value, keys) {
2126  return keys.reduce(function (hashMap, key) {
2127    hashMap[key] = value;
2128    return hashMap;
2129  }, {});
2130}
2131;// ./node_modules/@popperjs/core/lib/utils/detectOverflow.js
2132
2133
2134
2135
2136
2137
2138
2139
2140 // eslint-disable-next-line import/no-unused-modules
2141
2142function detectOverflow(state, options) {
2143  if (options === void 0) {
2144    options = {};
2145  }
2146
2147  var _options = options,
2148      _options$placement = _options.placement,
2149      placement = _options$placement === void 0 ? state.placement : _options$placement,
2150      _options$boundary = _options.boundary,
2151      boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,
2152      _options$rootBoundary = _options.rootBoundary,
2153      rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,
2154      _options$elementConte = _options.elementContext,
2155      elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,
2156      _options$altBoundary = _options.altBoundary,
2157      altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,
2158      _options$padding = _options.padding,
2159      padding = _options$padding === void 0 ? 0 : _options$padding;
2160  var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2161  var altContext = elementContext === popper ? reference : popper;
2162  var popperRect = state.rects.popper;
2163  var element = state.elements[altBoundary ? altContext : elementContext];
2164  var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary);
2165  var referenceClientRect = getBoundingClientRect(state.elements.reference);
2166  var popperOffsets = computeOffsets({
2167    reference: referenceClientRect,
2168    element: popperRect,
2169    strategy: 'absolute',
2170    placement: placement
2171  });
2172  var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets));
2173  var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect
2174  // 0 or negative = within the clipping rect
2175
2176  var overflowOffsets = {
2177    top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
2178    bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
2179    left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
2180    right: elementClientRect.right - clippingClientRect.right + paddingObject.right
2181  };
2182  var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element
2183
2184  if (elementContext === popper && offsetData) {
2185    var offset = offsetData[placement];

2186    Object.keys(overflowOffsets).forEach(function (key) {
2187      var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
2188      var axis = [enums_top, bottom].indexOf(key) >= 0 ? 'y' : 'x';
2189      overflowOffsets[key] += offset[axis] * multiply;
2190    });
2191  }
2192
2193  return overflowOffsets;
2194}
2195;// ./node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js
2196
2197
2198
2199
2200function computeAutoPlacement(state, options) {
2201  if (options === void 0) {
2202    options = {};
2203  }
2204
2205  var _options = options,
2206      placement = _options.placement,
2207      boundary = _options.boundary,
2208      rootBoundary = _options.rootBoundary,
2209      padding = _options.padding,
2210      flipVariations = _options.flipVariations,
2211      _options$allowedAutoP = _options.allowedAutoPlacements,
2212      allowedAutoPlacements = _options$allowedAutoP === void 0 ? enums_placements : _options$allowedAutoP;
2213  var variation = getVariation(placement);
2214  var placements = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) {
2215    return getVariation(placement) === variation;
2216  }) : basePlacements;
2217  var allowedPlacements = placements.filter(function (placement) {
2218    return allowedAutoPlacements.indexOf(placement) >= 0;
2219  });
2220
2221  if (allowedPlacements.length === 0) {
2222    allowedPlacements = placements;
2223
2224    if (false) {}

2224
2225  } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...
2226
2227
2228  var overflows = allowedPlacements.reduce(function (acc, placement) {
2229    acc[placement] = detectOverflow(state, {
2230      placement: placement,
2231      boundary: boundary,
2232      rootBoundary: rootBoundary,
2233      padding: padding
2234    })[getBasePlacement(placement)];
2235    return acc;
2236  }, {});
2237  return Object.keys(overflows).sort(function (a, b) {
2238    return overflows[a] - overflows[b];
2239  });
2240}
2241;// ./node_modules/@popperjs/core/lib/modifiers/flip.js
2242
2243
2244
2245
2246
2247
2248 // eslint-disable-next-line import/no-unused-modules
2249
2250function getExpandedFallbackPlacements(placement) {
2251  if (getBasePlacement(placement) === auto) {
2252    return [];
2253  }
2254
2255  var oppositePlacement = getOppositePlacement(placement);
2256  return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
2257}
2258
2259function flip(_ref) {
2260  var state = _ref.state,
2261      options = _ref.options,
2262      name = _ref.name;
2263
2264  if (state.modifiersData[name]._skip) {
2265    return;
2266  }
2267
2268  var _options$mainAxis = options.mainAxis,
2269      checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
2270      _options$altAxis = options.altAxis,
2271      checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis,
2272      specifiedFallbackPlacements = options.fallbackPlacements,
2273      padding = options.padding,
2274      boundary = options.boundary,
2275      rootBoundary = options.rootBoundary,
2276      altBoundary = options.altBoundary,
2277      _options$flipVariatio = options.flipVariations,
2278      flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio,
2279      allowedAutoPlacements = options.allowedAutoPlacements;
2280  var preferredPlacement = state.options.placement;
2281  var basePlacement = getBasePlacement(preferredPlacement);
2282  var isBasePlacement = basePlacement === preferredPlacement;
2283  var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
2284  var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) {
2285    return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, {
2286      placement: placement,
2287      boundary: boundary,
2288      rootBoundary: rootBoundary,
2289      padding: padding,
2290      flipVariations: flipVariations,
2291      allowedAutoPlacements: allowedAutoPlacements
2292    }) : placement);
2293  }, []);
2294  var referenceRect = state.rects.reference;
2295  var popperRect = state.rects.popper;
2296  var checksMap = new Map();
2297  var makeFallbackChecks = true;
2298  var firstFittingPlacement = placements[0];
2299
2300  for (var i = 0; i < placements.length; i++) {
2301    var placement = placements[i];
2302
2303    var _basePlacement = getBasePlacement(placement);
2304
2305    var isStartVariation = getVariation(placement) === start;
2306    var isVertical = [enums_top, bottom].indexOf(_basePlacement) >= 0;
2307    var len = isVertical ? 'width' : 'height';
2308    var overflow = detectOverflow(state, {
2309      placement: placement,
2310      boundary: boundary,
2311      rootBoundary: rootBoundary,
2312      altBoundary: altBoundary,
2313      padding: padding
2314    });
2315    var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : enums_top;
2316
2317    if (referenceRect[len] > popperRect[len]) {
2318      mainVariationSide = getOppositePlacement(mainVariationSide);
2319    }
2320
2321    var altVariationSide = getOppositePlacement(mainVariationSide);
2322    var checks = [];
2323
2324    if (checkMainAxis) {
2325      checks.push(overflow[_basePlacement] <= 0);
2326    }
2327
2328    if (checkAltAxis) {
2329      checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
2330    }
2331
2332    if (checks.every(function (check) {
2333      return check;
2334    })) {
2335      firstFittingPlacement = placement;
2336      makeFallbackChecks = false;
2337      break;
2338    }
2339
2340    checksMap.set(placement, checks);
2341  }
2342
2343  if (makeFallbackChecks) {
2344    // `2` may be desired in some cases – research later
2345    var numberOfChecks = flipVariations ? 3 : 1;
2346
2347    var _loop = function _loop(_i) {
2348      var fittingPlacement = placements.find(function (placement) {
2349        var checks = checksMap.get(placement);
2350
2351        if (checks) {
2352          return checks.slice(0, _i).every(function (check) {
2353            return check;
2354          });
2355        }
2356      });
2357
2358      if (fittingPlacement) {
2359        firstFittingPlacement = fittingPlacement;
2360        return "break";
2361      }
2362    };
2363
2364    for (var _i = numberOfChecks; _i > 0; _i--) {
2365      var _ret = _loop(_i);
2366
2367      if (_ret === "break") break;
2368    }
2369  }
2370
2371  if (state.placement !== firstFittingPlacement) {
2372    state.modifiersData[name]._skip = true;
2373    state.placement = firstFittingPlacement;
2374    state.reset = true;
2375  }
2376} // eslint-disable-next-line import/no-unused-modules
2377
2378
2379/* harmony default export */ const modifiers_flip = ({
2380  name: 'flip',
2381  enabled: true,
2382  phase: 'main',
2383  fn: flip,
2384  requiresIfExists: ['offset'],
2385  data: {
2386    _skip: false
2387  }
2388});
2389;// ./node_modules/@popperjs/core/lib/utils/getAltAxis.js
2390function getAltAxis(axis) {
2391  return axis === 'x' ? 'y' : 'x';
2392}
2393;// ./node_modules/@popperjs/core/lib/utils/within.js
2394
2395function within(min, value, max) {
2396  return math_max(min, math_min(value, max));
2397}
2398function withinMaxClamp(min, value, max) {
2399  var v = within(min, value, max);
2400  return v > max ? max : v;
2401}
2402;// ./node_modules/@popperjs/core/lib/modifiers/preventOverflow.js
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415function preventOverflow(_ref) {
2416  var state = _ref.state,
2417      options = _ref.options,
2418      name = _ref.name;
2419  var _options$mainAxis = options.mainAxis,
2420      checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
2421      _options$altAxis = options.altAxis,
2422      checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis,
2423      boundary = options.boundary,
2424      rootBoundary = options.rootBoundary,
2425      altBoundary = options.altBoundary,
2426      padding = options.padding,
2427      _options$tether = options.tether,
2428      tether = _options$tether === void 0 ? true : _options$tether,
2429      _options$tetherOffset = options.tetherOffset,
2430      tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
2431  var overflow = detectOverflow(state, {
2432    boundary: boundary,
2433    rootBoundary: rootBoundary,
2434    padding: padding,
2435    altBoundary: altBoundary
2436  });
2437  var basePlacement = getBasePlacement(state.placement);
2438  var variation = getVariation(state.placement);
2439  var isBasePlacement = !variation;
2440  var mainAxis = getMainAxisFromPlacement(basePlacement);
2441  var altAxis = getAltAxis(mainAxis);
2442  var popperOffsets = state.modifiersData.popperOffsets;
2443  var referenceRect = state.rects.reference;
2444  var popperRect = state.rects.popper;
2445  var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, {
2446    placement: state.placement
2447  })) : tetherOffset;
2448  var normalizedTetherOffsetValue = typeof tetherOffsetValue === 'number' ? {
2449    mainAxis: tetherOffsetValue,
2450    altAxis: tetherOffsetValue
2451  } : Object.assign({
2452    mainAxis: 0,
2453    altAxis: 0
2454  }, tetherOffsetValue);
2455  var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
2456  var data = {
2457    x: 0,
2458    y: 0
2459  };
2460
2461  if (!popperOffsets) {
2462    return;
2463  }
2464
2465  if (checkMainAxis) {
2466    var _offsetModifierState$;
2467
2468    var mainSide = mainAxis === 'y' ? enums_top : left;
2469    var altSide = mainAxis === 'y' ? bottom : right;
2470    var len = mainAxis === 'y' ? 'height' : 'width';
2471    var offset = popperOffsets[mainAxis];
2472    var min = offset + overflow[mainSide];
2473    var max = offset - overflow[altSide];
2474    var additive = tether ? -popperRect[len] / 2 : 0;
2475    var minLen = variation === start ? referenceRect[len] : popperRect[len];
2476    var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go
2477    // outside the reference bounds
2478
2479    var arrowElement = state.elements.arrow;
2480    var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
2481      width: 0,
2482      height: 0
2483    };
2484    var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject();
2485    var arrowPaddingMin = arrowPaddingObject[mainSide];
2486    var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want
2487    // to include its full size in the calculation. If the reference is small
2488    // and near the edge of a boundary, the popper can overflow even if the
2489    // reference is not overflowing as well (e.g. virtual elements with no
2490    // width or height)
2491
2492    var arrowLen = within(0, referenceRect[len], arrowRect[len]);
2493    var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
2494    var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
2495    var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
2496    var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
2497    var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
2498    var tetherMin = offset + minOffset - offsetModifierValue - clientOffset;
2499    var tetherMax = offset + maxOffset - offsetModifierValue;
2500    var preventedOffset = within(tether ? math_min(min, tetherMin) : min, offset, tether ? math_max(max, tetherMax) : max);
2501    popperOffsets[mainAxis] = preventedOffset;
2502    data[mainAxis] = preventedOffset - offset;
2503  }
2504
2505  if (checkAltAxis) {
2506    var _offsetModifierState$2;
2507
2508    var _mainSide = mainAxis === 'x' ? enums_top : left;
2509
2510    var _altSide = mainAxis === 'x' ? bottom : right;
2511
2512    var _offset = popperOffsets[altAxis];
2513
2514    var _len = altAxis === 'y' ? 'height' : 'width';
2515
2516    var _min = _offset + overflow[_mainSide];
2517
2518    var _max = _offset - overflow[_altSide];
2519
2520    var isOriginSide = [enums_top, left].indexOf(basePlacement) !== -1;
2521
2522    var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
2523
2524    var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
2525
2526    var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
2527
2528    var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
2529
2530    popperOffsets[altAxis] = _preventedOffset;
2531    data[altAxis] = _preventedOffset - _offset;
2532  }
2533
2534  state.modifiersData[name] = data;
2535} // eslint-disable-next-line import/no-unused-modules
2536
2537
2538/* harmony default export */ const modifiers_preventOverflow = ({
2539  name: 'preventOverflow',
2540  enabled: true,
2541  phase: 'main',
2542  fn: preventOverflow,
2543  requiresIfExists: ['offset']
2544});
2545;// ./node_modules/@popperjs/core/lib/modifiers/arrow.js
2546
2547
2548
2549
2550
2551
2552
2553

2554
2555 // eslint-disable-next-line import/no-unused-modules
2556
2557var toPaddingObject = function toPaddingObject(padding, state) {
2558  padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, {
2559    placement: state.placement
2560  })) : padding;
2561  return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2562};
2563
2564function arrow(_ref) {
2565  var _state$modifiersData$;
2566
2567  var state = _ref.state,
2568      name = _ref.name,
2569      options = _ref.options;
2570  var arrowElement = state.elements.arrow;
2571  var popperOffsets = state.modifiersData.popperOffsets;
2572  var basePlacement = getBasePlacement(state.placement);
2573  var axis = getMainAxisFromPlacement(basePlacement);
2574  var isVertical = [left, right].indexOf(basePlacement) >= 0;
2575  var len = isVertical ? 'height' : 'width';
2576
2577  if (!arrowElement || !popperOffsets) {
2578    return;
2579  }
2580

2581  var paddingObject = toPaddingObject(options.padding, state);
2582  var arrowRect = getLayoutRect(arrowElement);
2583  var minProp = axis === 'y' ? enums_top : left;
2584  var maxProp = axis === 'y' ? bottom : right;
2585  var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
2586  var startDiff = popperOffsets[axis] - state.rects.reference[axis];
2587  var arrowOffsetParent = getOffsetParent(arrowElement);
2588  var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
2589  var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
2590  // outside of the popper bounds
2591
2592  var min = paddingObject[minProp];
2593  var max = clientSize - arrowRect[len] - paddingObject[maxProp];
2594  var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
2595  var offset = within(min, center, max); // Prevents breaking syntax highlighting...
2596
2597  var axisProp = axis;
2598  state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
2599}
2600
2601function arrow_effect(_ref2) {
2602  var state = _ref2.state,
2603      options = _ref2.options;
2604  var _options$element = options.element,
2605      arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element;
2606
2607  if (arrowElement == null) {
2608    return;
2609  } // CSS selector
2610
2611
2612  if (typeof arrowElement === 'string') {
2613    arrowElement = state.elements.popper.querySelector(arrowElement);
2614
2615    if (!arrowElement) {
2616      return;
2617    }
2618  }
2619
2620  if (false) {}
2621
2622  if (!contains(state.elements.popper, arrowElement)) {
2623    if (false) {}
2624
2625    return;
2626  }
2627
2628  state.elements.arrow = arrowElement;
2629} // eslint-disable-next-line import/no-unused-modules
2630
2631
2632/* harmony default export */ const modifiers_arrow = ({
2633  name: 'arrow',
2634  enabled: true,
2635  phase: 'main',
2636  fn: arrow,
2637  effect: arrow_effect,
2638  requires: ['popperOffsets'],
2639  requiresIfExists: ['preventOverflow']
2640});
2641;// ./node_modules/@popperjs/core/lib/modifiers/hide.js
2642
2643
2644
2645function getSideOffsets(overflow, rect, preventedOffsets) {
2646  if (preventedOffsets === void 0) {
2647    preventedOffsets = {
2648      x: 0,
2649      y: 0
2650    };
2651  }
2652
2653  return {
2654    top: overflow.top - rect.height - preventedOffsets.y,
2655    right: overflow.right - rect.width + preventedOffsets.x,
2656    bottom: overflow.bottom - rect.height + preventedOffsets.y,
2657    left: overflow.left - rect.width - preventedOffsets.x
2658  };
2659}
2660
2661function isAnySideFullyClipped(overflow) {
2662  return [enums_top, right, bottom, left].some(function (side) {
2663    return overflow[side] >= 0;
2664  });
2665}
2666
2667function hide(_ref) {
2668  var state = _ref.state,
2669      name = _ref.name;
2670  var referenceRect = state.rects.reference;
2671  var popperRect = state.rects.popper;
2672  var preventedOffsets = state.modifiersData.preventOverflow;
2673  var referenceOverflow = detectOverflow(state, {
2674    elementContext: 'reference'
2675  });
2676  var popperAltOverflow = detectOverflow(state, {
2677    altBoundary: true
2678  });
2679  var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
2680  var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
2681  var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
2682  var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
2683  state.modifiersData[name] = {
2684    referenceClippingOffsets: referenceClippingOffsets,
2685    popperEscapeOffsets: popperEscapeOffsets,
2686    isReferenceHidden: isReferenceHidden,
2687    hasPopperEscaped: hasPopperEscaped
2688  };
2689  state.attributes.popper = Object.assign({}, state.attributes.popper, {
2690    'data-popper-reference-hidden': isReferenceHidden,
2691    'data-popper-escaped': hasPopperEscaped
2692  });
2693} // eslint-disable-next-line import/no-unused-modules
2694
2695
2696/* harmony default export */ const modifiers_hide = ({
2697  name: 'hide',
2698  enabled: true,
2699  phase: 'main',
2700  requiresIfExists: ['preventOverflow'],
2701  fn: hide
2702});
2703;// ./node_modules/@popperjs/core/lib/popper.js
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714var defaultModifiers = [eventListeners, modifiers_popperOffsets, modifiers_computeStyles, modifiers_applyStyles, modifiers_offset, modifiers_flip, modifiers_preventOverflow, modifiers_arrow, modifiers_hide];
2715var popper_createPopper = /*#__PURE__*/popperGenerator({
2716  defaultModifiers: defaultModifiers
2717}); // eslint-disable-next-line import/no-unused-modules
2718
2719 // eslint-disable-next-line import/no-unused-modules
2720
2721 // eslint-disable-next-line import/no-unused-modules
2722
2723
2724;// ./node_modules/tippy.js/dist/tippy.esm.js
2725/**!
2726* tippy.js v6.3.7
2727* (c) 2017-2021 atomiks
2728* MIT License
2729*/
2730
2731
2732var ROUND_ARROW = '<svg width="16" height="6" xmlns="http://www.w3.org/2000/svg"><path d="M0 6s1.796-.013 4.67-3.615C5.851.9 6.93.006 8 0c1.07-.006 2.148.887 3.343 2.385C14.233 6.005 16 6 16 6H0z"></svg>';
2733var BOX_CLASS = "tippy-box";
2734var CONTENT_CLASS = "tippy-content";
2735var BACKDROP_CLASS = "tippy-backdrop";
2736var ARROW_CLASS = "tippy-arrow";
2737var SVG_ARROW_CLASS = "tippy-svg-arrow";
2738var TOUCH_OPTIONS = {
2739  passive: true,
2740  capture: true
2741};
2742var TIPPY_DEFAULT_APPEND_TO = function TIPPY_DEFAULT_APPEND_TO() {
2743  return document.body;
2744};
2745
2746function tippy_esm_hasOwnProperty(obj, key) {
2747  return {}.hasOwnProperty.call(obj, key);
2748}
2749function getValueAtIndexOrReturn(value, index, defaultValue) {
2750  if (Array.isArray(value)) {
2751    var v = value[index];
2752    return v == null ? Array.isArray(defaultValue) ? defaultValue[index] : defaultValue : v;
2753  }
2754
2755  return value;
2756}
2757function isType(value, type) {
2758  var str = {}.toString.call(value);
2759  return str.indexOf('[object') === 0 && str.indexOf(type + "]") > -1;
2760}