https://mamabee.com/wp-content/plugins/wp-recipe-maker/dist/public-modern-split.js?ver=10.8.0

723    for (let container of containers) {
724      temperatures.push(WPRecipeMaker.temperature.getData(container));
725    }
726    return temperatures;
727  },
728  getData(container) {
729    return {
730      container,
731      value: container.dataset.value,
732      unit: container.dataset.unit,
733      help: container.dataset.tooltip
734    };
735  }
736};
737
738/***/ }),
739
740/***/ 4181:
741/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
742
743"use strict";
744
745// EXPORTS
746__webpack_require__.d(__webpack_exports__, {
747  Ay: () => (/* binding */ tippy_esm),
748  DX: () => (/* binding */ inlinePositioning)
749});
750
751// UNUSED EXPORTS: animateFill, createSingleton, delegate, followCursor, hideAll, roundArrow, sticky
752
753;// ./node_modules/@popperjs/core/lib/dom-utils/getWindow.js
754function getWindow(node) {
755  if (node == null) {
756    return window;
757  }
758
759  if (node.toString() !== '[object Window]') {
760    var ownerDocument = node.ownerDocument;
761    return ownerDocument ? ownerDocument.defaultView || window : window;
762  }
763
764  return node;
765}
766;// ./node_modules/@popperjs/core/lib/dom-utils/instanceOf.js
767
768
769function isElement(node) {
770  var OwnElement = getWindow(node).Element;
771  return node instanceof OwnElement || node instanceof Element;
772}
773
774function isHTMLElement(node) {
775  var OwnElement = getWindow(node).HTMLElement;
776  return node instanceof OwnElement || node instanceof HTMLElement;
777}
778
779function isShadowRoot(node) {
780  // IE 11 has no ShadowRoot
781  if (typeof ShadowRoot === 'undefined') {
782    return false;
783  }
784
785  var OwnElement = getWindow(node).ShadowRoot;
786  return node instanceof OwnElement || node instanceof ShadowRoot;
787}
788
789
790;// ./node_modules/@popperjs/core/lib/utils/math.js
791var math_max = Math.max;
792var math_min = Math.min;
793var round = Math.round;
794;// ./node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js
795
796
797function getBoundingClientRect(element, includeScale) {
798  if (includeScale === void 0) {
799    includeScale = false;
800  }
801
802  var rect = element.getBoundingClientRect();
803  var scaleX = 1;
804  var scaleY = 1;
805
806  if (isHTMLElement(element) && includeScale) {
807    var offsetHeight = element.offsetHeight;
808    var offsetWidth = element.offsetWidth; // Do not attempt to divide by 0, otherwise we get `Infinity` as scale
809    // Fallback to 1 in case both values are `0`
810
811    if (offsetWidth > 0) {
812      scaleX = round(rect.width) / offsetWidth || 1;
813    }
814
815    if (offsetHeight > 0) {
816      scaleY = round(rect.height) / offsetHeight || 1;
817    }
818  }
819
820  return {
821    width: rect.width / scaleX,
822    height: rect.height / scaleY,
823    top: rect.top / scaleY,
824    right: rect.right / scaleX,
825    bottom: rect.bottom / scaleY,
826    left: rect.left / scaleX,
827    x: rect.left / scaleX,
828    y: rect.top / scaleY
829  };
830}
831;// ./node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js
832
833function getWindowScroll(node) {
834  var win = getWindow(node);
835  var scrollLeft = win.pageXOffset;
836  var scrollTop = win.pageYOffset;
837  return {
838    scrollLeft: scrollLeft,
839    scrollTop: scrollTop
840  };
841}
842;// ./node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js
843function getHTMLElementScroll(element) {
844  return {
845    scrollLeft: element.scrollLeft,
846    scrollTop: element.scrollTop
847  };
848}
849;// ./node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js
850
851
852
853
854function getNodeScroll(node) {
855  if (node === getWindow(node) || !isHTMLElement(node)) {
856    return getWindowScroll(node);
857  } else {
858    return getHTMLElementScroll(node);
859  }
860}
861;// ./node_modules/@popperjs/core/lib/dom-utils/getNodeName.js
862function getNodeName(element) {
863  return element ? (element.nodeName || '').toLowerCase() : null;
864}
865;// ./node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js
866
867function getDocumentElement(element) {
868  // $FlowFixMe[incompatible-return]: assume body is always available
869  return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
870  element.document) || window.document).documentElement;
871}
872;// ./node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js
873
874
875
876function getWindowScrollBarX(element) {
877  // If <html> has a CSS width greater than the viewport, then this will be
878  // incorrect for RTL.
879  // Popper 1 is broken in this case and never had a bug report so let's assume
880  // it's not an issue. I don't think anyone ever specifies width on <html>
881  // anyway.
882  // Browsers where the left scrollbar doesn't cause an issue report `0` for
883  // this (e.g. Edge 2019, IE11, Safari)
884  return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
885}
886;// ./node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js
887
888function getComputedStyle(element) {
889  return getWindow(element).getComputedStyle(element);
890}
891;// ./node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js
892
893function isScrollParent(element) {
894  // Firefox wants us to check `-x` and `-y` variations as well
895  var _getComputedStyle = getComputedStyle(element),
896      overflow = _getComputedStyle.overflow,
897      overflowX = _getComputedStyle.overflowX,
898      overflowY = _getComputedStyle.overflowY;
899
900  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
901}
902;// ./node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js
903
904
905
906
907
908
909
910
911
912function isElementScaled(element) {
913  var rect = element.getBoundingClientRect();
914  var scaleX = round(rect.width) / element.offsetWidth || 1;
915  var scaleY = round(rect.height) / element.offsetHeight || 1;
916  return scaleX !== 1 || scaleY !== 1;
917} // Returns the composite rect of an element relative to its offsetParent.
918// Composite means it takes into account transforms as well as layout.
919
920

921function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
922  if (isFixed === void 0) {
923    isFixed = false;
924  }
925
926  var isOffsetParentAnElement = isHTMLElement(offsetParent);
927  var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
928  var documentElement = getDocumentElement(offsetParent);
929  var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled);
930  var scroll = {
931    scrollLeft: 0,
932    scrollTop: 0
933  };
934  var offsets = {
935    x: 0,
936    y: 0
937  };
938
939  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
940    if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
941    isScrollParent(documentElement)) {
942      scroll = getNodeScroll(offsetParent);
943    }
944
945    if (isHTMLElement(offsetParent)) {
946      offsets = getBoundingClientRect(offsetParent, true);
947      offsets.x += offsetParent.clientLeft;
948      offsets.y += offsetParent.clientTop;
949    } else if (documentElement) {
950      offsets.x = getWindowScrollBarX(documentElement);
951    }
952  }
953
954  return {
955    x: rect.left + scroll.scrollLeft - offsets.x,
956    y: rect.top + scroll.scrollTop - offsets.y,
957    width: rect.width,
958    height: rect.height
959  };
960}
961;// ./node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js
962 // Returns the layout rect of an element relative to its offsetParent. Layout
963// means it doesn't take into account transforms.
964
965function getLayoutRect(element) {
966  var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.
967  // Fixes https://github.com/popperjs/popper-core/issues/1223
968
969  var width = element.offsetWidth;
970  var height = element.offsetHeight;
971
972  if (Math.abs(clientRect.width - width) <= 1) {
973    width = clientRect.width;
974  }
975
976  if (Math.abs(clientRect.height - height) <= 1) {
977    height = clientRect.height;
978  }
979
980  return {
981    x: element.offsetLeft,
982    y: element.offsetTop,
983    width: width,
984    height: height
985  };
986}
987;// ./node_modules/@popperjs/core/lib/dom-utils/getParentNode.js
988
989
990
991function getParentNode(element) {
992  if (getNodeName(element) === 'html') {
993    return element;
994  }
995
996  return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
997    // $FlowFixMe[incompatible-return]
998    // $FlowFixMe[prop-missing]
999    element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
1000    element.parentNode || ( // DOM Element detected
1001    isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
1002    // $FlowFixMe[incompatible-call]: HTMLElement is a Node
1003    getDocumentElement(element) // fallback
1004
1005  );
1006}
1007;// ./node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js
1008
1009
1010
1011
1012function getScrollParent(node) {
1013  if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
1014    // $FlowFixMe[incompatible-return]: assume body is always available
1015    return node.ownerDocument.body;
1016  }
1017
1018  if (isHTMLElement(node) && isScrollParent(node)) {
1019    return node;
1020  }
1021
1022  return getScrollParent(getParentNode(node));
1023}
1024;// ./node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js
1025
1026
1027
1028
1029/*
1030given a DOM element, return the list of all scroll parents, up the list of ancesors
1031until we get to the top window object. This list is what we attach scroll listeners
1032to, because if any of these parent elements scroll, we'll need to re-calculate the
1033reference element's position.
1034*/
1035
1036function listScrollParents(element, list) {
1037  var _element$ownerDocumen;
1038
1039  if (list === void 0) {
1040    list = [];
1041  }
1042
1043  var scrollParent = getScrollParent(element);
1044  var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
1045  var win = getWindow(scrollParent);
1046  var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
1047  var updatedList = list.concat(target);
1048  return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
1049  updatedList.concat(listScrollParents(getParentNode(target)));
1050}
1051;// ./node_modules/@popperjs/core/lib/dom-utils/isTableElement.js
1052
1053function isTableElement(element) {
1054  return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
1055}
1056;

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

1171    requires.forEach(function (dep) {
1172      if (!visited.has(dep)) {
1173        var depModifier = map.get(dep);
1174
1175        if (depModifier) {
1176          sort(depModifier);
1177        }
1178      }
1179    });
1180    result.push(modifier);
1181  }
1182
1183  modifiers.forEach(function (modifier) {
1184    if (!visited.has(modifier.name)) {
1185      // check for visited object
1186      sort(modifier);
1187    }
1188  });
1189  return result;
1190}
1191
1192function orderModifiers(modifiers) {
1193  // order based on dependencies
1194  var orderedModifiers = order(modifiers); // order based on phase
1195
1196  return modifierPhases.reduce(function (acc, phase) {
1197    return acc.concat(orderedModifiers.filter(function (modifier) {
1198      return modifier.phase === phase;
1199    }));
1200  }, []);
1201}
1202;// ./node_modules/@popperjs/core/lib/utils/debounce.js
1203function debounce(fn) {
1204  var pending;
1205  return function () {
1206    if (!pending) {
1207      pending = new Promise(function (resolve) {
1208        Promise.resolve().then(function () {
1209          pending = undefined;
1210          resolve(fn());
1211        });
1212      });
1213    }
1214
1215    return pending;
1216  };
1217}
1218;// ./node_modules/@popperjs/core/lib/utils/mergeByName.js
1219function mergeByName(modifiers) {
1220  var merged = modifiers.reduce(function (merged, current) {
1221    var existing = merged[current.name];
1222    merged[current.name] = existing ? Object.assign({}, existing, current, {
1223      options: Object.assign({}, existing.options, current.options),
1224      data: Object.assign({}, existing.data, current.data)
1225    }) : current;
1226    return merged;
1227  }, {}); // IE11 does not support Object.values
1228
1229  return Object.keys(merged).map(function (key) {
1230    return merged[key];
1231  });
1232}
1233;//

1233 ./node_modules/@popperjs/core/lib/createPopper.js
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248var INVALID_ELEMENT_ERROR = 'Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.';
1249var INFINITE_LOOP_ERROR = 'Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.';
1250var DEFAULT_OPTIONS = {
1251  placement: 'bottom',
1252  modifiers: [],
1253  strategy: 'absolute'
1254};
1255
1256function areValidElements() {
1257  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
1258    args[_key] = arguments[_key];
1259  }
1260
1261  return !args.some(function (element) {
1262    return !(element && typeof element.getBoundingClientRect === 'function');
1263  });
1264}
1265
1266function popperGenerator(generatorOptions) {
1267  if (generatorOptions === void 0) {
1268    generatorOptions = {};
1269  }
1270
1271  var _generatorOptions = generatorOptions,
1272      _generatorOptions$def = _generatorOptions.defaultModifiers,
1273      defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def,
1274      _generatorOptions$def2 = _generatorOptions.defaultOptions,
1275      defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
1276  return function createPopper(reference, popper, options) {
1277    if (options === void 0) {
1278      options = defaultOptions;
1279    }
1280
1281    var state = {
1282      placement: 'bottom',
1283      orderedModifiers: [],
1284      options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
1285      modifiersData: {},
1286      elements: {
1287        reference: reference,
1288        popper: popper
1289      },
1290      attributes: {},
1291      styles: {}
1292    };
1293    var effectCleanupFns = [];
1294    var isDestroyed = false;
1295    var instance = {
1296      state: state,
1297      setOptions: function setOptions(setOptionsAction) {
1298        var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction;
1299        cleanupModifierEffects();
1300        state.options = Object.assign({}, defaultOptions, state.options, options);
1301        state.scrollParents = {
1302          reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],
1303          popper: listScrollParents(popper)
1304        }; // Orders the modifiers based on their dependencies and `phase`
1305        // properties
1306
1307        var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers
1308
1309        state.orderedModifiers = orderedModifiers.filter(function (m) {
1310          return m.enabled;
1311        }); // Validate the provided modifiers so that the consumer will get warned
1312        // if one of the modifiers is invalid for any reason
1313
1314        if (false) { var _getComputedStyle, marginTop, marginRight, marginBottom, marginLeft, flipModifier, modifiers; }
1315
1316        runModifierEffects();
1317        return instance.update();
1318      },
1319      // Sync update – it will always be executed, even if not necessary. This
1320      // is useful for low frequency updates where sync behavior simplifies the
1321      // logic.
1322      // For high frequency updates (e.g. `resize` and `scroll` events), always
1323      // prefer the async Popper#update method
1324      forceUpdate: function forceUpdate() {
1325        if (isDestroyed) {
1326          return;
1327        }
1328
1329        var _state$elements = state.elements,
1330            reference = _state$elements.reference,
1331            popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements
1332        // anymore
1333
1334        if (!areValidElements(reference, popper)) {
1335          if (false) {}
1336
1337          return;
1338        } // Store the reference and popper rects to be read by modifiers
1339
1340
1341        state.rects = {
1342          reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'),
1343          popper: getLayoutRect(popper)
1344        }; // Modifiers have the ability to reset the current update cycle. The
1345        // most common use case for this is the `flip` modifier changing the
1346        // placement, which then needs to re-run all the modifiers, because the
1347        // logic was previously ran for the previous placement and is therefore
1348        // stale/incorrect
1349
1350        state.reset = false;
1351        state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier
1352        // is filled with the initial data specified by the modifier. This means
1353        // it doesn't persist and is fresh on each update.
1354        // To ensure persistent data, use `${name}#persistent`
1355
1356        state.orderedModifiers.forEach(function (modifier) {
1357          return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
1358        });
1359        var __debug_loops__ = 0;
1360
1361        for (var index = 0; index < state.orderedModifiers.length; index++) {
1362          if (false) {}
1363
1364          if (state.reset === true) {
1365            state.reset = false;
1366            index = -1;
1367            continue;
1368          }
1369
1370          var _state$orderedModifie = state.orderedModifiers[index],
1371              fn = _state$orderedModifie.fn,
1372              _state$orderedModifie2 = _state$orderedModifie.options,
1373              _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2,
1374              name = _state$orderedModifie.name;
1375
1376          if (typeof fn === 'function') {
1377            state = fn({
1378              state: state,
1379              options: _options,
1380              name: name,
1381              instance: instance
1382            }) || state;
1383          }
1384        }
1385      },
1386      // Async and optimistically optimized update – it will not be executed if
1387      // not necessary (debounced to run at most once-per-tick)
1388      update: debounce(function () {
1389        return new Promise(function (resolve) {
1390          instance.forceUpdate();
1391          resolve(state);
1392        });
1393      }),
1394      destroy: function destroy() {
1395        cleanupModifierEffects();
1396        isDestroyed = true;
1397      }
1398    };
1399
1400    if (!areValidElements(reference, popper)) {
1401      if (false) {}
1402
1403      return instance;
1404    }
1405
1406    instance.setOptions(options).then(function (state) {
1407      if (!isDestroyed && options.onFirstUpdate) {
1408        options.onFirstUpdate(state);
1409      }
1410    }); // Modifiers have the ability to execute arbitrary code before the first
1411    // update cycle runs. They will be executed in the same order as the update
1412    // cycle. This is useful when a modifier adds some persistent data that
1413    // other modifiers need to use, but the modifier is run after the dependent
1414    // one.
1415
1416    function runModifierEffects() {
1417      state.orderedModifiers.forEach(function (_ref3) {
1418        var name = _ref3.name,
1419            _ref3$options = _ref3.options,
1420            options = _ref3$options === void 0 ? {} : _ref3$options,
1421            effect = _ref3.effect;
1422
1423        if (typeof effect === 'function') {
1424          var cleanupFn = effect({
1425            state: state,
1426            name: name,
1427            instance: instance,
1428            options: options
1429          });
1430
1431          var noopFn = function noopFn() {};
1432
1433          effectCleanupFns.push(cleanupFn || noopFn);
1434        }
1435      });
1436    }
1437
1438    function cleanupModifierEffects() {
1439      effectCleanupFns.forEach(function (fn) {
1440        return fn();
1441      });
1442      effectCleanupFns = [];
1443    }
1444
1445    return instance;
1446  };
1447}
1448var createPopper = /*#__PURE__*/(/* unused pure expression or super */ null && (popperGenerator())); // eslint-disable-next-line import/no-unused-modules
1449
1450
1451;// 

1451./node_modules/@popperjs/core/lib/modifiers/eventListeners.js
1452 // eslint-disable-next-line import/no-unused-modules
1453
1454var passive = {
1455  passive: true
1456};
1457
1458function effect(_ref) {
1459  var state = _ref.state,
1460      instance = _ref.instance,
1461      options = _ref.options;
1462  var _options$scroll = options.scroll,
1463      scroll = _options$scroll === void 0 ? true : _options$scroll,
1464      _options$resize = options.resize,
1465      resize = _options$resize === void 0 ? true : _options$resize;
1466  var window = getWindow(state.elements.popper);
1467  var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
1468
1469  if (scroll) {
1470    scrollParents.forEach(function (scrollParent) {
1471      scrollParent.addEventListener('scroll', instance.update, passive);
1472    });
1473  }
1474
1475  if (resize) {
1476    window.addEventListener('resize', instance.update, passive);
1477  }
1478
1479  return function () {
1480    if (scroll) {
1481      scrollParents.forEach(function (scrollParent) {
1482        scrollParent.removeEventListener('scroll', instance.update, passive);
1483      });
1484    }
1485
1486    if (resize) {
1487      window.removeEventListener('resize', instance.update, passive);
1488    }
1489  };
1490} // eslint-disable-next-line import/no-unused-modules
1491
1492
1493/* harmony default export */ const eventListeners = ({
1494  name: 'eventListeners',
1495  enabled: true,
1496  phase: 'write',
1497  fn: function fn() {},
1498  effect: effect,
1499  data: {}
1500});
1501;// ./node_modules/@popperjs/core/lib/utils/getBasePlacement.js
1502
1503function getBasePlacement(placement) {
1504  return placement.split('-')[0];
1505}
1506;// ./node_modules/@popperjs/core/lib/utils/getVariation.js
1507function getVariation(placement) {
1508  return placement.split('-')[1];
1509}
1510;// ./node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js
1511function getMainAxisFromPlacement(placement) {
1512  return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
1513}
1514;// ./node_modules/@popperjs/core/lib/utils/computeOffsets.js
1515
1516
1517
1518
1519function computeOffsets(_ref) {
1520  var reference = _ref.reference,
1521      element = _ref.element,
1522      placement = _ref.placement;
1523  var basePlacement = placement ? getBasePlacement(placement) : null;
1524  var variation = placement ? getVariation(placement) : null;
1525  var commonX = reference.x + reference.width / 2 - element.width / 2;
1526  var commonY = reference.y + reference.height / 2 - element.height / 2;
1527  var offsets;
1528
1529  switch (basePlacement) {
1530    case enums_top:
1531      offsets = {
1532        x: commonX,
1533        y: reference.y - element.height
1534      };
1535      break;
1536
1537    case bottom:
1538      offsets = {
1539        x: commonX,
1540        y: reference.y + reference.height
1541      };
1542      break;
1543
1544    case right:
1545      offsets = {
1546        x: reference.x + reference.width,
1547        y: commonY
1548      };
1549      break;
1550
1551    case left:
1552      offsets = {
1553        x: reference.x - element.width,
1554        y: commonY
1555      };
1556      break;
1557
1558    default:
1559      offsets = {
1560        x: reference.x,
1561        y: reference.y
1562      };
1563  }
1564
1565  var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
1566
1567  if (mainAxis != null) {
1568    var len = mainAxis === 'y' ? 'height' : 'width';
1569
1570    switch (variation) {
1571      case start:
1572        offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
1573        break;
1574
1575      case end:
1576        offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
1577        break;
1578
1579      default:
1580    }
1581  }
1582
1583  return offsets;
1584}
1585;// ./node_modules/@popperjs/core/lib/modifiers/popperOffsets.js
1586
1587
1588function popperOffsets(_ref) {
1589  var state = _ref.state,
1590      name = _ref.name;
1591  // Offsets are the actual position the popper needs to have to be
1592  // properly positioned near its reference element
1593  // This is the most basic placement, and will be adjusted by
1594  // the modifiers in the next step
1595  state.modifiersData[name] = computeOffsets({
1596    reference: state.rects.reference,
1597    element: state.rects.popper,
1598    strategy: 'absolute',
1599    placement: state.placement
1600  });
1601} // eslint-disable-next-line import/no-unused-modules
1602
1603
1604/* harmony default export */ const modifiers_popperOffsets = ({
1605  name: 'popperOffsets',
1606  enabled: true,
1607  phase: 'read',
1608  fn: popperOffsets,
1609  data: {}
1610});
1611;// ./node_modules/@popperjs/core/lib/modifiers/computeStyles.js
1612
1613
1614
1615
1616
1617
1618
1619 // eslint-disable-next-line import/no-unused-modules
1620
1621var unsetSides = {
1622  top: 'auto',
1623  right: 'auto',
1624  bottom: 'auto',
1625  left: 'auto'
1626}; // Round the offsets to the nearest suitable subpixel based on the DPR.
1627// Zooming can change the DPR, but it seems to report a value that will
1628// cleanly divide the values into the appropriate subpixels.
1629
1630function roundOffsetsByDPR(_ref) {
1631  var x = _ref.x,
1632      y = _ref.y;
1633  var win = window;
1634  var dpr = win.devicePixelRatio || 1;
1635  return {
1636    x: round(x * dpr) / dpr || 0,
1637    y: round(y * dpr) / dpr || 0
1638  };
1639}
1640
1641function mapToStyles(_ref2) {
1642  var _Object$assign2;
1643
1644  var popper = _ref2.popper,
1645      popperRect = _ref2.popperRect,
1646      placement = _ref2.placement,
1647      variation = _ref2.variation,
1648      offsets = _ref2.offsets,
1649      position = _ref2.position,
1650      gpuAcceleration = _ref2.gpuAcceleration,
1651      adaptive = _ref2.adaptive,
1652      roundOffsets = _ref2.roundOffsets,
1653      isFixed = _ref2.isFixed;
1654  var _offsets$x = offsets.x,
1655      x = _offsets$x === void 0 ? 0 : _offsets$x,
1656      _offsets$y = offsets.y,
1657      y = _offsets$y === void 0 ? 0 : _offsets$y;
1658
1659  var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({
1660    x: x,
1661    y: y
1662  }) : {
1663    x: x,
1664    y: y
1665  };
1666
1667  x = _ref3.x;
1668  y = _ref3.y;
1669  var hasX = offsets.hasOwnProperty('x');
1670  var hasY = offsets.hasOwnProperty('y');
1671  var sideX = left;
1672  var sideY = enums_top;
1673  var win = window;
1674
1675  if (adaptive) {
1676    var offsetParent = getOffsetParent(popper);
1677    var heightProp = 'clientHeight';

1678    var widthProp = 'clientWidth';
1679
1680    if (offsetParent === getWindow(popper)) {
1681      offsetParent = getDocumentElement(popper);
1682
1683      if (getComputedStyle(offsetParent).position !== 'static' && position === 'absolute') {
1684        heightProp = 'scrollHeight';
1685        widthProp = 'scrollWidth';
1686      }
1687    } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
1688
1689
1690    offsetParent = offsetParent;
1691
1692    if (placement === enums_top || (placement === left || placement === right) && variation === end) {
1693      sideY = bottom;
1694      var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing]
1695      offsetParent[heightProp];
1696      y -= offsetY - popperRect.height;
1697      y *= gpuAcceleration ? 1 : -1;
1698    }
1699
1700    if (placement === left || (placement === enums_top || placement === bottom) && variation === end) {
1701      sideX = right;
1702      var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing]
1703      offsetParent[widthProp];
1704      x -= offsetX - popperRect.width;
1705      x *= gpuAcceleration ? 1 : -1;
1706    }
1707  }
1708
1709  var commonStyles = Object.assign({
1710    position: position
1711  }, adaptive && unsetSides);
1712
1713  var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
1714    x: x,
1715    y: y
1716  }) : {
1717    x: x,
1718    y: y
1719  };
1720
1721  x = _ref4.x;
1722  y = _ref4.y;
1723
1724  if (gpuAcceleration) {
1725    var _Object$assign;
1726
1727    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));
1728  }
1729
1730  return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
1731}
1732
1733function computeStyles(_ref5) {
1734  var state = _ref5.state,
1735      options = _ref5.options;
1736  var _options$gpuAccelerat = options.gpuAcceleration,
1737      gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
1738      _options$adaptive = options.adaptive,
1739      adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
1740      _options$roundOffsets = options.roundOffsets,
1741      roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
1742
1743  if (false) { var transitionProperty; }
1744
1745  var commonStyles = {
1746    placement: getBasePlacement(state.placement),
1747    variation: getVariation(state.placement),
1748    popper: state.elements.popper,
1749    popperRect: state.rects.popper,
1750    gpuAcceleration: gpuAcceleration,
1751    isFixed: state.options.strategy === 'fixed'
1752  };
1753
1754  if (state.modifiersData.popperOffsets != null) {
1755    state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
1756      offsets: state.modifiersData.popperOffsets,
1757      position: state.options.strategy,
1758      adaptive: adaptive,
1759      roundOffsets: roundOffsets
1760    })));
1761  }
1762
1763  if (state.modifiersData.arrow != null) {
1764    state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
1765      offsets: state.modifiersData.arrow,
1766      position: 'absolute',
1767      adaptive: false,
1768      roundOffsets: roundOffsets
1769    })));
1770  }
1771
1772  state.attributes.popper = Object.assign({}, state.attributes.popper, {
1773    'data-popper-placement': state.placement
1774  });
1775} // eslint-disable-next-line import/no-unused-modules
1776
1777
1778/* harmony default export */ const modifiers_computeStyles = ({
1779  name: 'computeStyles',
1780  enabled: true,
1781  phase: 'beforeWrite',
1782  fn: computeStyles,
1783  data: {}
1784});
1785;// ./node_modules/@popperjs/core/lib/modifiers/applyStyles.js
1786
1787 // This modifier takes the styles prepared by the `computeStyles` modifier
1788// and applies them to the HTMLElements such as popper and arrow
1789
1790function applyStyles(_ref) {
1791  var state = _ref.state;

1792  Object.keys(state.elements).forEach(function (name) {
1793    var style = state.styles[name] || {};
1794    var attributes = state.attributes[name] || {};
1795    var element = state.elements[name]; // arrow is optional + virtual elements
1796
1797    if (!isHTMLElement(element) || !getNodeName(element)) {
1798      return;
1799    } // Flow doesn't support to extend this property, but it's the most
1800    // effective way to apply styles to an HTMLElement
1801    // $FlowFixMe[cannot-write]
1802
1803
1804    Object.assign(element.style, style);
1805    Object.keys(attributes).forEach(function (name) {
1806      var value = attributes[name];
1807
1808      if (value === false) {
1809        element.removeAttribute(name);
1810      } else {
1811        element.setAttribute(name, value === true ? '' : value);
1812      }
1813    });
1814  });
1815}
1816
1817function applyStyles_effect(_ref2) {
1818  var state = _ref2.state;
1819  var initialStyles = {
1820    popper: {
1821      position: state.options.strategy,
1822      left: '0',
1823      top: '0',
1824      margin: '0'
1825    },
1826    arrow: {
1827      position: 'absolute'
1828    },
1829    reference: {}
1830  };
1831  Object.assign(state.elements.popper.style, initialStyles.popper);
1832  state.styles = initialStyles;
1833
1834  if (state.elements.arrow) {
1835    Object.assign(state.elements.arrow.style, initialStyles.arrow);
1836  }
1837
1838  return function () {
1839    Object.keys(state.elements).forEach(function (name) {
1840      var element = state.elements[name];
1841      var attributes = state.attributes[name] || {};
1842      var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
1843
1844      var style = styleProperties.reduce(function (style, property) {
1845        style[property] = '';
1846        return style;
1847      }, {}); // arrow is optional + virtual elements
1848
1849      if (!isHTMLElement(element) || !getNodeName(element)) {
1850        return;
1851      }
1852
1853      Object.assign(element.style, style);
1854      Object.keys(attributes).forEach(function (attribute) {
1855        element.removeAttribute(attribute);
1856      });
1857    });
1858  };
1859} // eslint-disable-next-line import/no-unused-modules
1860
1861
1862/* harmony default export */ const modifiers_applyStyles = ({
1863  name: 'applyStyles',
1864  enabled: true,
1865  phase: 'write',
1866  fn: applyStyles,
1867  effect: applyStyles_effect,
1868  requires: ['computeStyles']
1869});
1870;// ./node_modules/@popperjs/core/lib/modifiers/offset.js
1871
1872 // eslint-disable-next-line import/no-unused-modules
1873
1874function distanceAndSkiddingToXY(placement, rects, offset) {
1875  var basePlacement = getBasePlacement(placement);
1876  var invertDistance = [left, enums_top].indexOf(basePlacement) >= 0 ? -1 : 1;
1877
1878  var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, {
1879    placement: placement
1880  })) : offset,
1881      skidding = _ref[0],
1882      distance = _ref[1];
1883
1884  skidding = skidding || 0;
1885  distance = (distance || 0) * invertDistance;
1886  return [left, right].indexOf(basePlacement) >= 0 ? {
1887    x: distance,
1888    y: skidding
1889  } : {
1890    x: skidding,
1891    y: distance
1892  };
1893}
1894
1895function offset(_ref2) {
1896  var state = _ref2.state,
1897      options = _ref2.options,
1898      name = _ref2.name;
1899  var _options$offset = options.offset,
1900      offset = _options$offset === void 0 ? [0, 0] : _options$offset;
1901  var data = enums_placements.reduce(function (acc, placement) {
1902    acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
1903    return acc;
1904  }, {});
1905  var _data$state$placement = data[state.placement],
1906      x = _data$state$placement.x,
1907      y = _data$state$placement.y;
1908
1909  if (state.modifiersData.popperOffsets != null) {
1910    state.modifiersData.popperOffsets.x += x;
1911    state.modifiersData.popperOffsets.y += y;
1912  }
1913
1914  state.modifiersData[name] = data;
1915} // eslint-disable-next-line import/no-unused-modules
1916
1917
1918/* harmony default export */ const modifiers_offset = ({
1919  name: 'offset',
1920  enabled: true,
1921  phase: 'main',
1922  requires: ['popperOffsets'],
1923  fn: offset
1924});
1925;// ./node_modules/@popperjs/core/lib/utils/getOppositePlacement.js
1926var hash = {
1927  left: 'right',
1928  right: 'left',
1929  bottom: 'top',
1930  top: 'bottom'
1931};
1932function getOppositePlacement(placement) {
1933  return placement.replace(/left|right|bottom|top/g, function (matched) {
1934    return hash[matched];
1935  });
1936}
1937;

1966    height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently)
1967    // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
1968    // errors due to floating point numbers, so we need to check precision.
1969    // Safari returns a number <= 0, usually < -1 when pinch-zoomed
1970    // Feature detection fails in mobile emulation mode in Chrome.
1971    // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
1972    // 0.001
1973    // Fallback here: "Not Safari" userAgent
1974
1975    if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
1976      x = visualViewport.offsetLeft;
1977      y = visualViewport.offsetTop;
1978    }
1979  }
1980
1981  return {
1982    width: width,
1983    height: height,
1984    x: x + getWindowScrollBarX(element),
1985    y: y
1986  };
1987}
1988;// ./node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js
1989
1990
1991
1992
1993 // Gets the entire size of the scrollable document area, even extending outside
1994// of the `<html>` and `<body>` rect bounds if horizontally scrollable
1995
1996function getDocumentRect(element) {
1997  var _element$ownerDocumen;
1998
1999  var html = getDocumentElement(element);
2000  var winScroll = getWindowScroll(element);
2001  var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
2002  var width = math_max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
2003  var height = math_max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
2004  var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
2005  var y = -winScroll.scrollTop;
2006
2007  if (getComputedStyle(body || html).direction === 'rtl') {
2008    x += math_max(html.clientWidth, body ? body.clientWidth : 0) - width;
2009  }
2010
2011  return {
2012    width: width,
2013    height: height,
2014    x: x,
2015    y: y
2016  };
2017}
2018;// ./node_modules/@popperjs/core/lib/dom-utils/contains.js
2019
2020function contains(parent, child) {
2021  var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method
2022
2023  if (parent.contains(child)) {
2024    return true;
2025  } // then fallback to custom implementation with Shadow DOM support
2026  else if (rootNode && isShadowRoot(rootNode)) {
2027      var next = child;
2028
2029      do {
2030        if (next && parent.isSameNode(next)) {
2031          return true;
2032        } // $FlowFixMe[prop-missing]: need a better way to handle this...
2033
2034
2035        next = next.parentNode || next.host;
2036      } while (next);
2037    } // Give up, the result is false
2038
2039
2040  return false;
2041}
2042;// ./node_modules/@popperjs/core/lib/utils/rectToClientRect.js
2043function rectToClientRect(rect) {
2044  return Object.assign({}, rect, {
2045    left: rect.x,
2046    top: rect.y,
2047    right: rect.x + rect.width,
2048    bottom: rect.y + rect.height
2049  });
2050}
2051;// ./node_modules/@popperjs/core/lib/dom-utils/getClippingRect.js
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067function getInnerBoundingClientRect(element) {
2068  var rect = getBoundingClientRect(element);
2069  rect.top = rect.top + element.clientTop;
2070  rect.left = rect.left + element.clientLeft;
2071  rect.bottom = rect.top + element.clientHeight;
2072  rect.right = rect.left + element.clientWidth;
2073  rect.width = element.clientWidth;
2074  rect.height = element.clientHeight;
2075  rect.x = rect.left;
2076  rect.y = rect.top;
2077  return rect;
2078}
2079
2080function getClientRectFromMixedType(element, clippingParent) {
2081  return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
2082} // A "clipping parent" is an overflowable container with the characteristic of
2083// clipping (or hiding) overflowing elements with a position different from
2084// `initial`
2085
2086
2087function getClippingParents(element) {
2088  var clippingParents = listScrollParents(getParentNode(element));
2089  var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle(element).position) >= 0;
2090  var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
2091
2092  if (!isElement(clipperElement)) {
2093    return [];
2094  } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414
2095
2096
2097  return clippingParents.filter(function (clippingParent) {
2098    return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body';
2099  });
2100} // Gets the maximum area that the element is visible in due to any number of
2101// clipping parents
2102
2103
2104function getClippingRect(element, boundary, rootBoundary) {
2105  var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
2106  var clippingParents = [].concat(mainClippingParents, [rootBoundary]);
2107  var firstClippingParent = clippingParents[0];
2108  var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {
2109    var rect = getClientRectFromMixedType(element, clippingParent);
2110    accRect.top = math_max(rect.top, accRect.top);
2111    accRect.right = math_min(rect.right, accRect.right);
2112    accRect.bottom = math_min(rect.bottom, accRect.bottom);
2113    accRect.left = math_max(rect.left, accRect.left);
2114    return accRect;
2115  }, getClientRectFromMixedType(element, firstClippingParent));
2116  clippingRect.width = clippingRect.right - clippingRect.left;
2117  clippingRect.height = clippingRect.bottom - clippingRect.top;
2118  clippingRect.x = clippingRect.left;
2119  clippingRect.y = clippingRect.top;
2120  return clippingRect;
2121}
2122;// ./node_modules/@popperjs/core/lib/utils/getFreshSideObject.js
2123function getFreshSideObject() {
2124  return {
2125    top: 0,
2126    right: 0,
2127    bottom: 0,
2128    left: 0
2129  };
2130}
2131;// ./node_modules/@popperjs/core/lib/utils/mergePaddingObject.js
2132
2133function mergePaddingObject(paddingObject) {
2134  return Object.assign({}, getFreshSideObject(), paddingObject);
2135}
2136;// ./node_modules/@popperjs/core/lib/utils/expandToHashMap.js
2137function expandToHashMap(value, keys) {
2138  return keys.reduce(function (hashMap, key) {
2139    hashMap[key] = value;
2140    return hashMap;
2141  }, {});
2142}
2143;// ./node_modules/@popperjs/core/lib/utils/detectOverflow.js
2144
2145
2146
2147
2148
2149
2150
2151
2152 // eslint-disable-next-line import/no-unused-modules
2153
2154function detectOverflow(state, options) {
2155  if (options === void 0) {
2156    options = {};
2157  }
2158
2159  var _options = options,
2160      _options$placement = _options.placement,
2161      placement = _options$placement === void 0 ? state.placement : _options$placement,
2162      _options$boundary = _options.boundary,
2163      boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,
2164      _options$rootBoundary = _options.rootBoundary,
2165      rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,
2166      _options$elementConte = _options.elementContext,
2167      elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,
2168      _options$altBoundary = _options.altBoundary,
2169      altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,
2170      _options$padding = _options.padding,
2171      padding = _options$padding === void 0 ? 0 : _options$padding;
2172  var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2173  var altContext = elementContext === popper ? reference : popper;
2174  var popperRect = state.rects.popper;
2175  var element = state.elements[altBoundary ? altContext : elementContext];
2176  var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary);
2177  var referenceClientRect = getBoundingClientRect(state.elements.reference);
2178  var popperOffsets = computeOffsets({
2179    reference: referenceClientRect,
2180    element: popperRect,
2181    strategy: 'absolute',
2182    placement: placement
2183  });
2184  var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets));
2185  var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect
2186  // 0 or negative = within the clipping rect
2187
2188  var overflowOffsets = {
2189    top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
2190    bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
2191    left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
2192    right: elementClientRect.right - clippingClientRect.right + paddingObject.right
2193  };
2194  var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element
2195
2196  if (elementContext === popper && offsetData) {
2197    var offset = offsetData[placement];

2198    Object.keys(overflowOffsets).forEach(function (key) {
2199      var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
2200      var axis = [enums_top, bottom].indexOf(key) >= 0 ? 'y' : 'x';
2201      overflowOffsets[key] += offset[axis] * multiply;
2202    });
2203  }
2204
2205  return overflowOffsets;
2206}
2207;// ./node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js
2208
2209
2210
2211
2212function computeAutoPlacement(state, options) {
2213  if (options === void 0) {
2214    options = {};
2215  }
2216
2217  var _options = options,
2218      placement = _options.placement,
2219      boundary = _options.boundary,
2220      rootBoundary = _options.rootBoundary,
2221      padding = _options.padding,
2222      flipVariations = _options.flipVariations,
2223      _options$allowedAutoP = _options.allowedAutoPlacements,
2224      allowedAutoPlacements = _options$allowedAutoP === void 0 ? enums_placements : _options$allowedAutoP;
2225  var variation = getVariation(placement);
2226  var placements = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) {
2227    return getVariation(placement) === variation;
2228  }) : basePlacements;
2229  var allowedPlacements = placements.filter(function (placement) {
2230    return allowedAutoPlacements.indexOf(placement) >= 0;
2231  });
2232
2233  if (allowedPlacements.length === 0) {
2234    allowedPlacements = placements;
2235
2236    if (false) {}

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

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