{"version":3,"sources":["webpack:///./node_modules/react-overlays/esm/useRootClose.js","webpack:///./node_modules/react-overlays/esm/ownerDocument.js","webpack:///./node_modules/warning/warning.js","webpack:///./node_modules/@restart/hooks/esm/useCallbackRef.js","webpack:///./node_modules/react-bootstrap/esm/Tooltip.js","webpack:///./node_modules/react-overlays/esm/safeFindDOMNode.js","webpack:///./node_modules/prop-types-extra/lib/isRequiredForA11y.js","webpack:///./node_modules/@restart/hooks/esm/useSafeState.js","webpack:///./node_modules/react-overlays/esm/usePopper.js","webpack:///./node_modules/@popperjs/core/lib/utils/getBasePlacement.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/contains.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getWindow.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getNodeName.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/instanceOf.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/isTableElement.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js","webpack:///./node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js","webpack:///./node_modules/@popperjs/core/lib/utils/within.js","webpack:///./node_modules/@popperjs/core/lib/utils/mergePaddingObject.js","webpack:///./node_modules/@popperjs/core/lib/utils/getFreshSideObject.js","webpack:///./node_modules/@popperjs/core/lib/utils/expandToHashMap.js","webpack:///./node_modules/@popperjs/core/lib/enums.js","webpack:///./node_modules/@popperjs/core/lib/modifiers/arrow.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js","webpack:///./node_modules/@popperjs/core/lib/modifiers/computeStyles.js","webpack:///./node_modules/@popperjs/core/lib/modifiers/eventListeners.js","webpack:///./node_modules/@popperjs/core/lib/utils/getOppositePlacement.js","webpack:///./node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getParentNode.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getBorders.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getDecorations.js","webpack:///./node_modules/@popperjs/core/lib/utils/rectToClientRect.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getClippingRect.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js","webpack:///./node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js","webpack:///./node_modules/@popperjs/core/lib/utils/getVariation.js","webpack:///./node_modules/@popperjs/core/lib/utils/computeOffsets.js","webpack:///./node_modules/@popperjs/core/lib/utils/detectOverflow.js","webpack:///./node_modules/@popperjs/core/lib/modifiers/flip.js","webpack:///./node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js","webpack:///./node_modules/@popperjs/core/lib/modifiers/hide.js","webpack:///./node_modules/@popperjs/core/lib/modifiers/offset.js","webpack:///./node_modules/@popperjs/core/lib/modifiers/popperOffsets.js","webpack:///./node_modules/@popperjs/core/lib/modifiers/preventOverflow.js","webpack:///./node_modules/@popperjs/core/lib/utils/getAltAxis.js","webpack:///./node_modules/@popperjs/core/lib/utils/orderModifiers.js","webpack:///./node_modules/@popperjs/core/lib/index.js","webpack:///./node_modules/@popperjs/core/lib/utils/debounce.js","webpack:///./node_modules/@popperjs/core/lib/utils/mergeByName.js","webpack:///./node_modules/react-overlays/esm/popper.js","webpack:///./node_modules/@restart/hooks/esm/useTimeout.js","webpack:///./node_modules/@restart/hooks/esm/useMergedRefs.js","webpack:///./node_modules/react-overlays/esm/Overlay.js","webpack:///./node_modules/react-bootstrap/node_modules/dom-helpers/esm/hasClass.js","webpack:///./node_modules/react-bootstrap/esm/usePopperMarginModifiers.js","webpack:///./node_modules/react-bootstrap/esm/Overlay.js","webpack:///./node_modules/react-bootstrap/esm/OverlayTrigger.js","webpack:///./node_modules/react-bootstrap/node_modules/dom-helpers/esm/contains.js"],"names":["noop","getRefTarget","ref","current","onRootClose","_temp","_ref","disabled","_ref$clickTrigger","clickTrigger","preventMouseRootCloseRef","onClose","handleMouseCapture","e","event","currentTarget","metaKey","altKey","ctrlKey","shiftKey","button","isLeftClickEvent","contains","target","handleMouse","useEventCallback","handleKeyUp","keyCode","doc","ownerDocument","safeFindDOMNode","componentOrElement","removeMouseCaptureListener","listen","removeMouseListener","removeKeyupListener","mobileSafariHackListeners","documentElement","slice","call","body","children","map","el","forEach","remove","warning","module","exports","useCallbackRef","Tooltip","forwardRef","bsPrefix","placement","className","style","arrowProps","props","popper","show","createElement","role","defaultProps","displayName","findDOMNode","Object","defineProperty","value","default","validator","propName","componentName","location","propFullName","componentNameSafe","propFullNameSafe","Error","_len","arguments","length","args","Array","_key","apply","undefined","concat","state","isMounted","useMounted","nextState","initialPopperStyles","position","top","left","opacity","pointerEvents","initialArrowStyles","toModifierMap","modifiers","result","isArray","m","name","referenceElement","popperElement","_ref$enabled","enabled","_ref$placement","_ref$strategy","strategy","_ref$eventsEnabled","eventsEnabled","userModifiers","popperOptions","popperInstanceRef","scheduleUpdate","update","_useSafeState","outOfBoundaries","styles","arrowStyles","setState","updateModifier","phase","requires","fn","data","_data$state$modifiers","_data$state$styles","_data$state$styles2","modifiersData","hide","isReferenceHidden","arrow","keys","k","eventsModifier","find","setOptions","destroy","s","getBasePlacement","split","getLayoutRect","element","x","offsetLeft","y","offsetTop","width","offsetWidth","height","offsetHeight","parent","child","isShadow","Boolean","getRootNode","host","next","isSameNode","parentNode","getWindow","node","toString","defaultView","window","getNodeName","nodeName","toLowerCase","getComputedStyle","isElement","Element","isHTMLElement","HTMLElement","isTableElement","indexOf","getTrueOffsetParent","offsetParent","getOffsetParent","getMainAxisFromPlacement","within","min","max","Math","mergePaddingObject","paddingObject","assign","right","bottom","expandToHashMap","reduce","hashMap","key","basePlacements","variationPlacements","acc","modifierPhases","_state$modifiersData$","arrowElement","elements","popperOffsets","basePlacement","axis","len","padding","arrowRect","minProp","maxProp","endDiff","rects","reference","startDiff","arrowOffsetParent","clientSize","clientHeight","clientWidth","centerToReference","center","offset","axisProp","centerOffset","effect","_ref2","options","_options$element","_options$padding","querySelector","requiresIfExists","getDocumentElement","document","unsetSides","mapToStyles","_Object$assign2","popperRect","offsets","gpuAcceleration","adaptive","_roundOffsets","dpr","devicePixelRatio","round","roundOffsets","hasX","hasOwnProperty","hasY","sideX","sideY","win","_Object$assign","commonStyles","transform","_ref3","_options$gpuAccelerat","_options$adaptive","attributes","passive","instance","_options$scroll","scroll","_options$resize","resize","scrollParents","scrollParent","addEventListener","removeEventListener","hash","getOppositePlacement","replace","matched","start","end","getOppositeVariationPlacement","getBoundingClientRect","rect","getWindowScroll","scrollLeft","pageXOffset","scrollTop","pageYOffset","getWindowScrollBarX","isScrollParent","_getComputedStyle","overflow","overflowX","overflowY","test","getCompositeRect","elementOrVirtualElement","isFixed","clientLeft","clientTop","getParentNode","assignedSlot","listScrollParents","list","getScrollParent","isBody","visualViewport","updatedList","toNumber","cssValue","parseFloat","getDecorations","borders","computedStyle","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","getBorders","isHTML","winScrollBarX","innerHeight","innerWidth","rectToClientRect","getClientRectFromMixedType","clippingParent","navigator","platform","getViewportRect","winScroll","documentRect","getDocumentRect","getClippingRect","boundary","rootBoundary","mainClippingParents","clippingParents","clipperElement","filter","getClippingParents","firstClippingParent","clippingRect","accRect","decorations","getVariation","computeOffsets","variation","commonX","commonY","mainAxis","floor","ceil","detectOverflow","_options","_options$placement","_options$boundary","_options$rootBoundary","_options$elementConte","elementContext","_options$altBoundary","altBoundary","altContext","clippingClientRect","contextElement","referenceClientRect","popperClientRect","elementClientRect","overflowOffsets","offsetData","multiply","_skip","_options$mainAxis","checkMainAxis","_options$altAxis","altAxis","checkAltAxis","specifiedFallbackPlacements","fallbackPlacements","_options$flipVariatio","flipVariations","allowedAutoPlacements","preferredPlacement","oppositePlacement","getExpandedFallbackPlacements","placements","_options$allowedAutoP","overflows","sort","a","b","computeAutoPlacement","referenceRect","checksMap","Map","makeFallbackChecks","firstFittingPlacement","i","_basePlacement","isStartVariation","isVertical","mainVariationSide","altVariationSide","checks","push","every","check","set","_loop","_i","fittingPlacement","get","reset","getSideOffsets","preventedOffsets","isAnySideFullyClipped","some","side","preventOverflow","referenceOverflow","popperAltOverflow","referenceClippingOffsets","popperEscapeOffsets","hasPopperEscaped","_options$offset","invertDistance","skidding","distance","distanceAndSkiddingToXY","_data$state$placement","_options$tether","tether","_options$tetherOffset","tetherOffset","isBasePlacement","tetherOffsetValue","mainSide","altSide","additive","minLen","maxLen","arrowPaddingObject","arrowPaddingMin","arrowPaddingMax","arrowLen","minOffset","maxOffset","clientOffset","offsetModifierValue","tetherMin","tetherMax","preventedOffset","_mainSide","_altSide","_offset","_preventedOffset","order","visited","Set","modifier","has","add","dep","depModifier","DEFAULT_OPTIONS","areValidElements","popperGenerator","generatorOptions","_generatorOptions","_generatorOptions$def","defaultModifiers","_generatorOptions$def2","defaultOptions","pending","orderedModifiers","effectCleanupFns","isDestroyed","cleanupModifierEffects","orderModifiers","merged","existing","mergeByName","_ref3$options","cleanupFn","forceUpdate","_state$elements","index","_state$orderedModifie","_state$orderedModifie2","Promise","resolve","then","onFirstUpdate","eventListeners","MAX_DELAY_MS","pow","useTimeout","handleRef","useWillUnmount","clearTimeout","clear","delayMs","setTimeout","setChainedTimeout","timeoutAtMs","Date","now","toFnRef","refA","refB","mergeRefs","Overlay","outerRef","_modifiers$preventOve","_modifiers$arrow","flip","_props$containerPaddi","containerPadding","_props$popperConfig","popperConfig","Transition","transition","_useCallbackRef","rootElement","attachRef","_useCallbackRef2","attachArrowRef","mergedRef","container","useWaitForDOMRef","_useState","exited","setExited","_usePopper","usePopper","mountOverlay","useRootClose","onHide","rootClose","rootCloseDisabled","rootCloseEvent","onExit","onExiting","onEnter","onEntering","onEntered","appear","onExited","createPortal","propTypes","bool","oneOf","any","func","isRequired","number","object","_PropTypes$func","elementType","hasClass","classList","baseVal","usePopperMarginModifiers","overlayRef","margins","overlay","marginTop","marginRight","marginBottom","marginLeft","margin","_margins$current","Fade","_ref$popperConfig","outerProps","popperRef","_usePopperMarginModif","marginModifiers","overlayProps","aRef","__wrapped","r","wrapRefs","cloneElement","_React$Component","RefHolder","this","prototype","render","Component","handleMouseOverOut","handler","relatedNative","context","related","relatedTarget","nativeEvent","compareDocumentPosition","OverlayTrigger","trigger","defaultShow","propsDelay","delay","_ref$flip","triggerNodeRef","timeout","hoverStateRef","setShow","normalizeDelay","Children","only","_child$props","onFocus","onBlur","onClick","getTarget","handleShow","handleHide","handleFocus","handleBlur","handleClick","prevShow","handleMouseOver","handleMouseOut","ariaModifier","removeAttribute","getAttribute","id","setAttribute","triggers","triggerProps","onMouseOver","onMouseOut","Fragment"],"mappings":"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","file":"2d1bdf9b52f48a81fb58e3c9319b41b2e253c3b4-decc0b64810724fe5bd9.js","sourcesContent":["import contains from 'dom-helpers/contains';\nimport listen from 'dom-helpers/listen';\nimport { useCallback, useEffect, useRef } from 'react';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport warning from 'warning';\nimport ownerDocument from './ownerDocument';\nvar escapeKeyCode = 27;\n\nvar noop = function noop() {};\n\nfunction isLeftClickEvent(event) {\n  return event.button === 0;\n}\n\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\nvar getRefTarget = function getRefTarget(ref) {\n  return ref && ('current' in ref ? ref.current : ref);\n};\n/**\n * The `useRootClose` hook registers your callback on the document\n * when rendered. Powers the `<Overlay/>` component. This is used achieve modal\n * style behavior where your callback is triggered when the user tries to\n * interact with the rest of the document or hits the `esc` key.\n *\n * @param {Ref<HTMLElement>| HTMLElement} ref  The element boundary\n * @param {function} onRootClose\n * @param {object=}  options\n * @param {boolean=} options.disabled\n * @param {string=}  options.clickTrigger The DOM event name (click, mousedown, etc) to attach listeners on\n */\n\n\nfunction useRootClose(ref, onRootClose, _temp) {\n  var _ref = _temp === void 0 ? {} : _temp,\n      disabled = _ref.disabled,\n      _ref$clickTrigger = _ref.clickTrigger,\n      clickTrigger = _ref$clickTrigger === void 0 ? 'click' : _ref$clickTrigger;\n\n  var preventMouseRootCloseRef = useRef(false);\n  var onClose = onRootClose || noop;\n  var handleMouseCapture = useCallback(function (e) {\n    var currentTarget = getRefTarget(ref);\n    warning(!!currentTarget, 'RootClose captured a close event but does not have a ref to compare it to. ' + 'useRootClose(), should be passed a ref that resolves to a DOM node');\n    preventMouseRootCloseRef.current = !currentTarget || isModifiedEvent(e) || !isLeftClickEvent(e) || !!contains(currentTarget, e.target);\n  }, [ref]);\n  var handleMouse = useEventCallback(function (e) {\n    if (!preventMouseRootCloseRef.current) {\n      onClose(e);\n    }\n  });\n  var handleKeyUp = useEventCallback(function (e) {\n    if (e.keyCode === escapeKeyCode) {\n      onClose(e);\n    }\n  });\n  useEffect(function () {\n    if (disabled || ref == null) return undefined;\n    var doc = ownerDocument(getRefTarget(ref)); // Use capture for this listener so it fires before React's listener, to\n    // avoid false positives in the contains() check below if the target DOM\n    // element is removed in the React mouse callback.\n\n    var removeMouseCaptureListener = listen(doc, clickTrigger, handleMouseCapture, true);\n    var removeMouseListener = listen(doc, clickTrigger, handleMouse);\n    var removeKeyupListener = listen(doc, 'keyup', handleKeyUp);\n    var mobileSafariHackListeners = [];\n\n    if ('ontouchstart' in doc.documentElement) {\n      mobileSafariHackListeners = [].slice.call(doc.body.children).map(function (el) {\n        return listen(el, 'mousemove', noop);\n      });\n    }\n\n    return function () {\n      removeMouseCaptureListener();\n      removeMouseListener();\n      removeKeyupListener();\n      mobileSafariHackListeners.forEach(function (remove) {\n        return remove();\n      });\n    };\n  }, [ref, disabled, clickTrigger, handleMouseCapture, handleMouse, handleKeyUp]);\n}\n\nexport default useRootClose;","import ownerDocument from 'dom-helpers/ownerDocument';\nimport safeFindDOMNode from './safeFindDOMNode';\nexport default (function (componentOrElement) {\n  return ownerDocument(safeFindDOMNode(componentOrElement));\n});","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nrequire(\"core-js/modules/es6.regexp.replace\");\n\nvar __DEV__ = process.env.NODE_ENV !== 'production';\n\nvar warning = function warning() {};\n\nif (__DEV__) {\n  var printWarning = function printWarning(format, args) {\n    var len = arguments.length;\n    args = new Array(len > 1 ? len - 1 : 0);\n\n    for (var key = 1; key < len; key++) {\n      args[key - 1] = arguments[key];\n    }\n\n    var argIndex = 0;\n    var message = 'Warning: ' + format.replace(/%s/g, function () {\n      return args[argIndex++];\n    });\n\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) {}\n  };\n\n  warning = function warning(condition, format, args) {\n    var len = arguments.length;\n    args = new Array(len > 2 ? len - 2 : 0);\n\n    for (var key = 2; key < len; key++) {\n      args[key - 2] = arguments[key];\n    }\n\n    if (format === undefined) {\n      throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\n    }\n\n    if (!condition) {\n      printWarning.apply(null, [format].concat(args));\n    }\n  };\n}\n\nmodule.exports = warning;","import { useState } from 'react';\n/**\n * A convenience hook around `useState` designed to be paired with\n * the component [callback ref](https://reactjs.org/docs/refs-and-the-dom.html#callback-refs) api.\n * Callback refs are useful over `useRef()` when you need to respond to the ref being set\n * instead of lazily accessing it in an effect.\n *\n * ```ts\n * const [element, attachRef] = useCallbackRef<HTMLDivElement>()\n *\n * useEffect(() => {\n *   if (!element) return\n *\n *   const calendar = new FullCalendar.Calendar(element)\n *\n *   return () => {\n *     calendar.destroy()\n *   }\n * }, [element])\n *\n * return <div ref={attachRef} />\n * ```\n *\n * @category refs\n */\n\nexport default function useCallbackRef() {\n  return useState(null);\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport classNames from 'classnames';\nimport React from 'react';\nimport isRequiredForA11y from 'prop-types-extra/lib/isRequiredForA11y';\nimport { useBootstrapPrefix } from './ThemeProvider';\nvar defaultProps = {\n  placement: 'right'\n};\nvar Tooltip = React.forwardRef(function (_ref, ref) {\n  var bsPrefix = _ref.bsPrefix,\n      placement = _ref.placement,\n      className = _ref.className,\n      style = _ref.style,\n      children = _ref.children,\n      arrowProps = _ref.arrowProps,\n      _ = _ref.popper,\n      _2 = _ref.show,\n      props = _objectWithoutPropertiesLoose(_ref, [\"bsPrefix\", \"placement\", \"className\", \"style\", \"children\", \"arrowProps\", \"popper\", \"show\"]);\n\n  bsPrefix = useBootstrapPrefix(bsPrefix, 'tooltip');\n  return /*#__PURE__*/React.createElement(\"div\", _extends({\n    ref: ref,\n    style: style,\n    role: \"tooltip\",\n    \"x-placement\": placement,\n    className: classNames(className, bsPrefix, \"bs-tooltip-\" + placement)\n  }, props), /*#__PURE__*/React.createElement(\"div\", _extends({\n    className: \"arrow\"\n  }, arrowProps)), /*#__PURE__*/React.createElement(\"div\", {\n    className: bsPrefix + \"-inner\"\n  }, children));\n});\nTooltip.defaultProps = defaultProps;\nTooltip.displayName = 'Tooltip';\nexport default Tooltip;","import ReactDOM from 'react-dom';\nexport default function safeFindDOMNode(componentOrElement) {\n  if (componentOrElement && 'setState' in componentOrElement) {\n    return ReactDOM.findDOMNode(componentOrElement);\n  }\n\n  return componentOrElement != null ? componentOrElement : null;\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = isRequiredForA11y;\n\nfunction isRequiredForA11y(validator) {\n  return function validate(props, propName, componentName, location, propFullName) {\n    var componentNameSafe = componentName || '<<anonymous>>';\n    var propFullNameSafe = propFullName || propName;\n\n    if (props[propName] == null) {\n      return new Error('The ' + location + ' `' + propFullNameSafe + '` is required to make ' + ('`' + componentNameSafe + '` accessible for users of assistive ') + 'technologies such as screen readers.');\n    }\n\n    for (var _len = arguments.length, args = Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {\n      args[_key - 5] = arguments[_key];\n    }\n\n    return validator.apply(undefined, [props, propName, componentName, location, propFullName].concat(args));\n  };\n}\n\nmodule.exports = exports['default'];","import { useCallback } from 'react';\nimport useMounted from './useMounted';\n\nfunction useSafeState(state) {\n  var isMounted = useMounted();\n  return [state[0], useCallback(function (nextState) {\n    if (!isMounted()) return;\n    return state[1](nextState);\n  }, [isMounted, state[1]])];\n}\n\nexport default useSafeState;","import \"core-js/modules/es6.array.find\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.object.keys\";\nimport \"core-js/modules/es6.function.name\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\nimport useSafeState from '@restart/hooks/useSafeState';\nimport { createPopper } from './popper';\nvar initialPopperStyles = {\n  position: 'absolute',\n  top: '0',\n  left: '0',\n  opacity: '0',\n  pointerEvents: 'none'\n};\nvar initialArrowStyles = {}; // until docjs supports type exports...\n\nexport function toModifierMap(modifiers) {\n  var result = {};\n\n  if (!Array.isArray(modifiers)) {\n    return modifiers || result;\n  } // eslint-disable-next-line no-unused-expressions\n\n\n  modifiers == null ? void 0 : modifiers.forEach(function (m) {\n    result[m.name] = m;\n  });\n  return result;\n}\nexport function toModifierArray(map) {\n  if (map === void 0) {\n    map = {};\n  }\n\n  if (Array.isArray(map)) return map;\n  return Object.keys(map).map(function (k) {\n    map[k].name = k;\n    return map[k];\n  });\n}\n/**\n * Position an element relative some reference element using Popper.js\n *\n * @param referenceElement\n * @param popperElement\n * @param {object}      options\n * @param {object=}     options.modifiers Popper.js modifiers\n * @param {boolean=}    options.enabled toggle the popper functionality on/off\n * @param {string=}     options.placement The popper element placement relative to the reference element\n * @param {string=}     options.strategy the positioning strategy\n * @param {boolean=}    options.eventsEnabled have Popper listen on window resize events to reposition the element\n * @param {function=}   options.onCreate called when the popper is created\n * @param {function=}   options.onUpdate called when the popper is updated\n *\n * @returns {UsePopperState} The popper state\n */\n\nfunction usePopper(referenceElement, popperElement, _temp) {\n  var _ref = _temp === void 0 ? {} : _temp,\n      _ref$enabled = _ref.enabled,\n      enabled = _ref$enabled === void 0 ? true : _ref$enabled,\n      _ref$placement = _ref.placement,\n      placement = _ref$placement === void 0 ? 'bottom' : _ref$placement,\n      _ref$strategy = _ref.strategy,\n      strategy = _ref$strategy === void 0 ? 'absolute' : _ref$strategy,\n      _ref$eventsEnabled = _ref.eventsEnabled,\n      eventsEnabled = _ref$eventsEnabled === void 0 ? true : _ref$eventsEnabled,\n      userModifiers = _ref.modifiers,\n      popperOptions = _objectWithoutPropertiesLoose(_ref, [\"enabled\", \"placement\", \"strategy\", \"eventsEnabled\", \"modifiers\"]);\n\n  var popperInstanceRef = useRef();\n  var scheduleUpdate = useCallback(function () {\n    if (popperInstanceRef.current) {\n      popperInstanceRef.current.update();\n    }\n  }, []);\n\n  var _useSafeState = useSafeState(useState({\n    placement: placement,\n    scheduleUpdate: scheduleUpdate,\n    outOfBoundaries: false,\n    styles: initialPopperStyles,\n    arrowStyles: initialArrowStyles\n  })),\n      state = _useSafeState[0],\n      setState = _useSafeState[1];\n\n  var updateModifier = useMemo(function () {\n    return {\n      name: 'updateStateModifier',\n      enabled: true,\n      phase: 'afterWrite',\n      requires: ['computeStyles'],\n      fn: function fn(data) {\n        var _data$state$modifiers, _data$state$styles, _data$state$styles2;\n\n        setState({\n          scheduleUpdate: scheduleUpdate,\n          outOfBoundaries: !!((_data$state$modifiers = data.state.modifiersData.hide) == null ? void 0 : _data$state$modifiers.isReferenceHidden),\n          placement: data.state.placement,\n          styles: _extends({}, (_data$state$styles = data.state.styles) == null ? void 0 : _data$state$styles.popper),\n          arrowStyles: _extends({}, (_data$state$styles2 = data.state.styles) == null ? void 0 : _data$state$styles2.arrow),\n          state: data.state\n        });\n      }\n    };\n  }, [scheduleUpdate, setState]);\n  var modifiers = toModifierArray(userModifiers);\n  var eventsModifier = modifiers.find(function (m) {\n    return m.name === 'eventListeners';\n  });\n\n  if (!eventsModifier && eventsEnabled) {\n    eventsModifier = {\n      name: 'eventListeners',\n      enabled: true\n    };\n    modifiers = [].concat(modifiers, [eventsModifier]);\n  } // A placement difference in state means popper determined a new placement\n  // apart from the props value. By the time the popper element is rendered with\n  // the new position Popper has already measured it, if the place change triggers\n  // a size change it will result in a misaligned popper. So we schedule an update to be sure.\n\n\n  useEffect(function () {\n    scheduleUpdate();\n  }, [state.placement, scheduleUpdate]);\n  useEffect(function () {\n    if (!popperInstanceRef.current || !enabled) return;\n    popperInstanceRef.current.setOptions({\n      placement: placement,\n      strategy: strategy,\n      modifiers: [].concat(modifiers, [updateModifier])\n    }); // intentionally NOT re-running on new modifiers\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [strategy, placement, eventsModifier.enabled, updateModifier, enabled]);\n  useEffect(function () {\n    if (!enabled || referenceElement == null || popperElement == null) {\n      return undefined;\n    }\n\n    popperInstanceRef.current = createPopper(referenceElement, popperElement, _extends({}, popperOptions, {\n      placement: placement,\n      strategy: strategy,\n      modifiers: [].concat(modifiers, [updateModifier])\n    }));\n    return function () {\n      if (popperInstanceRef.current != null) {\n        popperInstanceRef.current.destroy();\n        popperInstanceRef.current = undefined;\n        setState(function (s) {\n          return _extends({}, s, {\n            styles: initialPopperStyles,\n            arrowStyles: initialArrowStyles\n          });\n        });\n      }\n    }; // This is only run once to _create_ the popper\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [enabled, referenceElement, popperElement]);\n  return state;\n}\n\nexport default usePopper;","import \"core-js/modules/es6.regexp.split\";\nimport { auto } from \"../enums.js\";\nexport default function getBasePlacement(placement) {\n  return placement.split('-')[0];\n}","// Returns the layout rect of an element relative to its offsetParent. Layout\n// means it doesn't take into account transforms.\nexport default function getLayoutRect(element) {\n  return {\n    x: element.offsetLeft,\n    y: element.offsetTop,\n    width: element.offsetWidth,\n    height: element.offsetHeight\n  };\n}","export default function contains(parent, child) {\n  // $FlowFixMe: hasOwnProperty doesn't seem to work in tests\n  var isShadow = Boolean(child.getRootNode && child.getRootNode().host); // First, attempt with faster native method\n\n  if (parent.contains(child)) {\n    return true;\n  } // then fallback to custom implementation with Shadow DOM support\n  else if (isShadow) {\n      var next = child;\n\n      do {\n        if (next && parent.isSameNode(next)) {\n          return true;\n        } // $FlowFixMe: need a better way to handle this...\n\n\n        next = next.parentNode || next.host;\n      } while (next);\n    } // Give up, the result is false\n\n\n  return false;\n}","import \"core-js/modules/es6.regexp.to-string\";\nimport \"core-js/modules/es6.object.to-string\";\n\n/*:: import type { Window } from '../types'; */\n\n/*:: declare function getWindow(node: Node | Window): Window; */\nexport default function getWindow(node) {\n  if (node.toString() !== '[object Window]') {\n    var ownerDocument = node.ownerDocument;\n    return ownerDocument ? ownerDocument.defaultView : window;\n  }\n\n  return node;\n}","export default function getNodeName(element) {\n  return element ? (element.nodeName || '').toLowerCase() : null;\n}","import getWindow from \"./getWindow.js\";\nexport default function getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}","import getWindow from \"./getWindow.js\";\n/*:: declare function isElement(node: mixed): boolean %checks(node instanceof\n  Element); */\n\nfunction isElement(node) {\n  var OwnElement = getWindow(node).Element;\n  return node instanceof OwnElement || node instanceof Element;\n}\n/*:: declare function isHTMLElement(node: mixed): boolean %checks(node instanceof\n  HTMLElement); */\n\n\nfunction isHTMLElement(node) {\n  var OwnElement = getWindow(node).HTMLElement;\n  return node instanceof OwnElement || node instanceof HTMLElement;\n}\n\nexport { isElement, isHTMLElement };","import getNodeName from \"./getNodeName.js\";\nexport default function isTableElement(element) {\n  return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;\n}","import getWindow from \"./getWindow.js\";\nimport getNodeName from \"./getNodeName.js\";\nimport getComputedStyle from \"./getComputedStyle.js\";\nimport { isHTMLElement } from \"./instanceOf.js\";\nimport isTableElement from \"./isTableElement.js\";\n\nfunction getTrueOffsetParent(element) {\n  if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837\n  getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n\n  return element.offsetParent;\n}\n\nexport default function getOffsetParent(element) {\n  var window = getWindow(element);\n  var offsetParent = getTrueOffsetParent(element); // Find the nearest non-table offsetParent\n\n  while (offsetParent && isTableElement(offsetParent)) {\n    offsetParent = getTrueOffsetParent(offsetParent);\n  }\n\n  if (offsetParent && getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static') {\n    return window;\n  }\n\n  return offsetParent || window;\n}","export default function getMainAxisFromPlacement(placement) {\n  return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';\n}","export default function within(min, value, max) {\n  return Math.max(min, Math.min(value, max));\n}","import \"core-js/modules/es6.object.assign\";\nimport getFreshSideObject from \"./getFreshSideObject.js\";\nexport default function mergePaddingObject(paddingObject) {\n  return Object.assign({}, getFreshSideObject(), {}, paddingObject);\n}","export default function getFreshSideObject() {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0\n  };\n}","export default function expandToHashMap(value, keys) {\n  return keys.reduce(function (hashMap, key) {\n    hashMap[key] = value;\n    return hashMap;\n  }, {});\n}","export var top = 'top';\nexport var bottom = 'bottom';\nexport var right = 'right';\nexport var left = 'left';\nexport var auto = 'auto';\nexport var basePlacements = [top, bottom, right, left];\nexport var start = 'start';\nexport var end = 'end';\nexport var clippingParents = 'clippingParents';\nexport var viewport = 'viewport';\nexport var popper = 'popper';\nexport var reference = 'reference';\nexport var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {\n  return acc.concat([placement + \"-\" + start, placement + \"-\" + end]);\n}, []);\nexport var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {\n  return acc.concat([placement, placement + \"-\" + start, placement + \"-\" + end]);\n}, []); // modifiers that need to read the DOM\n\nexport var beforeRead = 'beforeRead';\nexport var read = 'read';\nexport var afterRead = 'afterRead'; // pure-logic modifiers\n\nexport var beforeMain = 'beforeMain';\nexport var main = 'main';\nexport var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)\n\nexport var beforeWrite = 'beforeWrite';\nexport var write = 'write';\nexport var afterWrite = 'afterWrite';\nexport var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];","import \"core-js/modules/es6.function.name\";\nimport getBasePlacement from \"../utils/getBasePlacement.js\";\nimport getLayoutRect from \"../dom-utils/getLayoutRect.js\";\nimport contains from \"../dom-utils/contains.js\";\nimport getOffsetParent from \"../dom-utils/getOffsetParent.js\";\nimport getMainAxisFromPlacement from \"../utils/getMainAxisFromPlacement.js\";\nimport within from \"../utils/within.js\";\nimport mergePaddingObject from \"../utils/mergePaddingObject.js\";\nimport expandToHashMap from \"../utils/expandToHashMap.js\";\nimport { left, right, basePlacements, top, bottom } from \"../enums.js\";\nimport { isHTMLElement } from \"../dom-utils/instanceOf.js\"; // eslint-disable-next-line import/no-unused-modules\n\nfunction arrow(_ref) {\n  var _state$modifiersData$;\n\n  var state = _ref.state,\n      name = _ref.name;\n  var arrowElement = state.elements.arrow;\n  var popperOffsets = state.modifiersData.popperOffsets;\n  var basePlacement = getBasePlacement(state.placement);\n  var axis = getMainAxisFromPlacement(basePlacement);\n  var isVertical = [left, right].indexOf(basePlacement) >= 0;\n  var len = isVertical ? 'height' : 'width';\n\n  if (!arrowElement || !popperOffsets) {\n    return;\n  }\n\n  var paddingObject = state.modifiersData[name + \"#persistent\"].padding;\n  var arrowRect = getLayoutRect(arrowElement);\n  var minProp = axis === 'y' ? top : left;\n  var maxProp = axis === 'y' ? bottom : right;\n  var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];\n  var startDiff = popperOffsets[axis] - state.rects.reference[axis];\n  var arrowOffsetParent = getOffsetParent(arrowElement);\n  var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;\n  var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is\n  // outside of the popper bounds\n\n  var min = paddingObject[minProp];\n  var max = clientSize - arrowRect[len] - paddingObject[maxProp];\n  var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;\n  var offset = within(min, center, max); // Prevents breaking syntax highlighting...\n\n  var axisProp = axis;\n  state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);\n}\n\nfunction effect(_ref2) {\n  var state = _ref2.state,\n      options = _ref2.options,\n      name = _ref2.name;\n  var _options$element = options.element,\n      arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element,\n      _options$padding = options.padding,\n      padding = _options$padding === void 0 ? 0 : _options$padding;\n\n  if (arrowElement == null) {\n    return;\n  } // CSS selector\n\n\n  if (typeof arrowElement === 'string') {\n    arrowElement = state.elements.popper.querySelector(arrowElement);\n\n    if (!arrowElement) {\n      return;\n    }\n  }\n\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!isHTMLElement(arrowElement)) {\n      console.error(['Popper: \"arrow\" element must be an HTMLElement (not an SVGElement).', 'To use an SVG arrow, wrap it in an HTMLElement that will be used as', 'the arrow.'].join(' '));\n    }\n  }\n\n  if (!contains(state.elements.popper, arrowElement)) {\n    if (process.env.NODE_ENV !== \"production\") {\n      console.error(['Popper: \"arrow\" modifier\\'s `element` must be a child of the popper', 'element.'].join(' '));\n    }\n\n    return;\n  }\n\n  state.elements.arrow = arrowElement;\n  state.modifiersData[name + \"#persistent\"] = {\n    padding: mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements))\n  };\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n  name: 'arrow',\n  enabled: true,\n  phase: 'main',\n  fn: arrow,\n  effect: effect,\n  requires: ['popperOffsets'],\n  requiresIfExists: ['preventOverflow']\n};","import { isElement } from \"./instanceOf.js\";\nexport default function getDocumentElement(element) {\n  // $FlowFixMe: assume body is always available\n  return (isElement(element) ? element.ownerDocument : element.document).documentElement;\n}","import \"core-js/modules/es6.object.assign\";\nimport { top, left, right, bottom } from \"../enums.js\";\nimport getOffsetParent from \"../dom-utils/getOffsetParent.js\";\nimport getWindow from \"../dom-utils/getWindow.js\";\nimport getDocumentElement from \"../dom-utils/getDocumentElement.js\";\nimport getComputedStyle from \"../dom-utils/getComputedStyle.js\";\nimport getBasePlacement from \"../utils/getBasePlacement.js\"; // eslint-disable-next-line import/no-unused-modules\n\nvar unsetSides = {\n  top: 'auto',\n  right: 'auto',\n  bottom: 'auto',\n  left: 'auto'\n}; // Round the offsets to the nearest suitable subpixel based on the DPR.\n// Zooming can change the DPR, but it seems to report a value that will\n// cleanly divide the values into the appropriate subpixels.\n\nfunction roundOffsets(_ref) {\n  var x = _ref.x,\n      y = _ref.y;\n  var win = window;\n  var dpr = win.devicePixelRatio || 1;\n  return {\n    x: Math.round(x * dpr) / dpr || 0,\n    y: Math.round(y * dpr) / dpr || 0\n  };\n}\n\nexport function mapToStyles(_ref2) {\n  var _Object$assign2;\n\n  var popper = _ref2.popper,\n      popperRect = _ref2.popperRect,\n      placement = _ref2.placement,\n      offsets = _ref2.offsets,\n      position = _ref2.position,\n      gpuAcceleration = _ref2.gpuAcceleration,\n      adaptive = _ref2.adaptive;\n\n  var _roundOffsets = roundOffsets(offsets),\n      x = _roundOffsets.x,\n      y = _roundOffsets.y;\n\n  var hasX = offsets.hasOwnProperty('x');\n  var hasY = offsets.hasOwnProperty('y');\n  var sideX = left;\n  var sideY = top;\n  var win = window;\n\n  if (adaptive) {\n    var offsetParent = getOffsetParent(popper);\n\n    if (offsetParent === getWindow(popper)) {\n      offsetParent = getDocumentElement(popper);\n    } // $FlowFixMe: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it\n\n    /*:: offsetParent = (offsetParent: Element); */\n\n\n    if (placement === top) {\n      sideY = bottom;\n      y -= offsetParent.clientHeight - popperRect.height;\n      y *= gpuAcceleration ? 1 : -1;\n    }\n\n    if (placement === left) {\n      sideX = right;\n      x -= offsetParent.clientWidth - popperRect.width;\n      x *= gpuAcceleration ? 1 : -1;\n    }\n  }\n\n  var commonStyles = Object.assign({\n    position: position\n  }, adaptive && unsetSides);\n\n  if (gpuAcceleration) {\n    var _Object$assign;\n\n    return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) < 2 ? \"translate(\" + x + \"px, \" + y + \"px)\" : \"translate3d(\" + x + \"px, \" + y + \"px, 0)\", _Object$assign));\n  }\n\n  return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + \"px\" : '', _Object$assign2[sideX] = hasX ? x + \"px\" : '', _Object$assign2.transform = '', _Object$assign2));\n}\n\nfunction computeStyles(_ref3) {\n  var state = _ref3.state,\n      options = _ref3.options;\n  var _options$gpuAccelerat = options.gpuAcceleration,\n      gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,\n      _options$adaptive = options.adaptive,\n      adaptive = _options$adaptive === void 0 ? true : _options$adaptive;\n\n  if (process.env.NODE_ENV !== \"production\") {\n    var transitionProperty = getComputedStyle(state.elements.popper).transitionProperty || '';\n\n    if (adaptive && ['transform', 'top', 'right', 'bottom', 'left'].some(function (property) {\n      return transitionProperty.indexOf(property) >= 0;\n    })) {\n      console.warn(['Popper: Detected CSS transitions on at least one of the following', 'CSS properties: \"transform\", \"top\", \"right\", \"bottom\", \"left\".', '\\n\\n', 'Disable the \"computeStyles\" modifier\\'s `adaptive` option to allow', 'for smooth transitions, or remove these properties from the CSS', 'transition declaration on the popper element if only transitioning', 'opacity or background-color for example.', '\\n\\n', 'We recommend using the popper element as a wrapper around an inner', 'element that can have any CSS property transitioned for animations.'].join(' '));\n    }\n  }\n\n  var commonStyles = {\n    placement: getBasePlacement(state.placement),\n    popper: state.elements.popper,\n    popperRect: state.rects.popper,\n    gpuAcceleration: gpuAcceleration\n  };\n\n  if (state.modifiersData.popperOffsets != null) {\n    state.styles.popper = Object.assign({}, state.styles.popper, {}, mapToStyles(Object.assign({}, commonStyles, {\n      offsets: state.modifiersData.popperOffsets,\n      position: state.options.strategy,\n      adaptive: adaptive\n    })));\n  }\n\n  if (state.modifiersData.arrow != null) {\n    state.styles.arrow = Object.assign({}, state.styles.arrow, {}, mapToStyles(Object.assign({}, commonStyles, {\n      offsets: state.modifiersData.arrow,\n      position: 'absolute',\n      adaptive: false\n    })));\n  }\n\n  state.attributes.popper = Object.assign({}, state.attributes.popper, {\n    'data-popper-placement': state.placement\n  });\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n  name: 'computeStyles',\n  enabled: true,\n  phase: 'beforeWrite',\n  fn: computeStyles,\n  data: {}\n};","import getWindow from \"../dom-utils/getWindow.js\"; // eslint-disable-next-line import/no-unused-modules\n\nvar passive = {\n  passive: true\n};\n\nfunction effect(_ref) {\n  var state = _ref.state,\n      instance = _ref.instance,\n      options = _ref.options;\n  var _options$scroll = options.scroll,\n      scroll = _options$scroll === void 0 ? true : _options$scroll,\n      _options$resize = options.resize,\n      resize = _options$resize === void 0 ? true : _options$resize;\n  var window = getWindow(state.elements.popper);\n  var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);\n\n  if (scroll) {\n    scrollParents.forEach(function (scrollParent) {\n      scrollParent.addEventListener('scroll', instance.update, passive);\n    });\n  }\n\n  if (resize) {\n    window.addEventListener('resize', instance.update, passive);\n  }\n\n  return function () {\n    if (scroll) {\n      scrollParents.forEach(function (scrollParent) {\n        scrollParent.removeEventListener('scroll', instance.update, passive);\n      });\n    }\n\n    if (resize) {\n      window.removeEventListener('resize', instance.update, passive);\n    }\n  };\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n  name: 'eventListeners',\n  enabled: true,\n  phase: 'write',\n  fn: function fn() {},\n  effect: effect,\n  data: {}\n};","import \"core-js/modules/es6.regexp.replace\";\nvar hash = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nexport default function getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, function (matched) {\n    return hash[matched];\n  });\n}","import \"core-js/modules/es6.regexp.replace\";\nvar hash = {\n  start: 'end',\n  end: 'start'\n};\nexport default function getOppositeVariationPlacement(placement) {\n  return placement.replace(/start|end/g, function (matched) {\n    return hash[matched];\n  });\n}","export default function getBoundingClientRect(element) {\n  var rect = element.getBoundingClientRect();\n  return {\n    width: rect.width,\n    height: rect.height,\n    top: rect.top,\n    right: rect.right,\n    bottom: rect.bottom,\n    left: rect.left,\n    x: rect.left,\n    y: rect.top\n  };\n}","import getWindow from \"./getWindow.js\";\nexport default function getWindowScroll(node) {\n  var win = getWindow(node);\n  var scrollLeft = win.pageXOffset;\n  var scrollTop = win.pageYOffset;\n  return {\n    scrollLeft: scrollLeft,\n    scrollTop: scrollTop\n  };\n}","import getBoundingClientRect from \"./getBoundingClientRect.js\";\nimport getDocumentElement from \"./getDocumentElement.js\";\nimport getWindowScroll from \"./getWindowScroll.js\";\nexport default function getWindowScrollBarX(element) {\n  // If <html> has a CSS width greater than the viewport, then this will be\n  // incorrect for RTL.\n  // Popper 1 is broken in this case and never had a bug report so let's assume\n  // it's not an issue. I don't think anyone ever specifies width on <html>\n  // anyway.\n  // Browsers where the left scrollbar doesn't cause an issue report `0` for\n  // this (e.g. Edge 2019, IE11, Safari)\n  return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;\n}","import getComputedStyle from \"./getComputedStyle.js\";\nexport default function isScrollParent(element) {\n  // Firefox wants us to check `-x` and `-y` variations as well\n  var _getComputedStyle = getComputedStyle(element),\n      overflow = _getComputedStyle.overflow,\n      overflowX = _getComputedStyle.overflowX,\n      overflowY = _getComputedStyle.overflowY;\n\n  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);\n}","import getBoundingClientRect from \"./getBoundingClientRect.js\";\nimport getNodeScroll from \"./getNodeScroll.js\";\nimport getNodeName from \"./getNodeName.js\";\nimport { isHTMLElement } from \"./instanceOf.js\";\nimport getWindowScrollBarX from \"./getWindowScrollBarX.js\";\nimport getDocumentElement from \"./getDocumentElement.js\";\nimport isScrollParent from \"./isScrollParent.js\"; // Returns the composite rect of an element relative to its offsetParent.\n// Composite means it takes into account transforms as well as layout.\n\nexport default function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n\n  var documentElement = getDocumentElement(offsetParent);\n  var rect = getBoundingClientRect(elementOrVirtualElement);\n  var scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  var offsets = {\n    x: 0,\n    y: 0\n  };\n\n  if (!isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078\n    isScrollParent(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n\n    if (isHTMLElement(offsetParent)) {\n      offsets = getBoundingClientRect(offsetParent);\n      offsets.x += offsetParent.clientLeft;\n      offsets.y += offsetParent.clientTop;\n    } else if (documentElement) {\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n\n  return {\n    x: rect.left + scroll.scrollLeft - offsets.x,\n    y: rect.top + scroll.scrollTop - offsets.y,\n    width: rect.width,\n    height: rect.height\n  };\n}","import getWindowScroll from \"./getWindowScroll.js\";\nimport getWindow from \"./getWindow.js\";\nimport { isHTMLElement } from \"./instanceOf.js\";\nimport getHTMLElementScroll from \"./getHTMLElementScroll.js\";\nexport default function getNodeScroll(node) {\n  if (node === getWindow(node) || !isHTMLElement(node)) {\n    return getWindowScroll(node);\n  } else {\n    return getHTMLElementScroll(node);\n  }\n}","export default function getHTMLElementScroll(element) {\n  return {\n    scrollLeft: element.scrollLeft,\n    scrollTop: element.scrollTop\n  };\n}","import getNodeName from \"./getNodeName.js\";\nimport getDocumentElement from \"./getDocumentElement.js\";\nexport default function getParentNode(element) {\n  if (getNodeName(element) === 'html') {\n    return element;\n  }\n\n  return (// $FlowFixMe: this is a quicker (but less type safe) way to save quite some bytes from the bundle\n    element.assignedSlot || // step into the shadow DOM of the parent of a slotted node\n    element.parentNode || // DOM Element detected\n    // $FlowFixMe: need a better way to handle this...\n    element.host || // ShadowRoot detected\n    // $FlowFixMe: HTMLElement is a Node\n    getDocumentElement(element) // fallback\n\n  );\n}","import getScrollParent from \"./getScrollParent.js\";\nimport getParentNode from \"./getParentNode.js\";\nimport getNodeName from \"./getNodeName.js\";\nimport getWindow from \"./getWindow.js\";\nimport isScrollParent from \"./isScrollParent.js\";\nexport default function listScrollParents(element, list) {\n  if (list === void 0) {\n    list = [];\n  }\n\n  var scrollParent = getScrollParent(element);\n  var isBody = getNodeName(scrollParent) === 'body';\n  var win = getWindow(scrollParent);\n  var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;\n  var updatedList = list.concat(target);\n  return isBody ? updatedList : // $FlowFixMe: isBody tells us target will be an HTMLElement here\n  updatedList.concat(listScrollParents(getParentNode(target)));\n}","import getParentNode from \"./getParentNode.js\";\nimport isScrollParent from \"./isScrollParent.js\";\nimport getNodeName from \"./getNodeName.js\";\nimport { isHTMLElement } from \"./instanceOf.js\";\nexport default function getScrollParent(node) {\n  if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {\n    // $FlowFixMe: assume body is always available\n    return node.ownerDocument.body;\n  }\n\n  if (isHTMLElement(node) && isScrollParent(node)) {\n    return node;\n  }\n\n  return getScrollParent(getParentNode(node));\n}","import getComputedStyle from \"./getComputedStyle.js\";\nimport { isHTMLElement } from \"./instanceOf.js\";\n\nfunction toNumber(cssValue) {\n  return parseFloat(cssValue) || 0;\n}\n\nexport default function getBorders(element) {\n  var computedStyle = isHTMLElement(element) ? getComputedStyle(element) : {};\n  return {\n    top: toNumber(computedStyle.borderTopWidth),\n    right: toNumber(computedStyle.borderRightWidth),\n    bottom: toNumber(computedStyle.borderBottomWidth),\n    left: toNumber(computedStyle.borderLeftWidth)\n  };\n}","import getBorders from \"./getBorders.js\";\nimport getNodeName from \"./getNodeName.js\";\nimport getWindow from \"./getWindow.js\";\nimport getWindowScrollBarX from \"./getWindowScrollBarX.js\"; // Borders + scrollbars\n\nexport default function getDecorations(element) {\n  var win = getWindow(element);\n  var borders = getBorders(element);\n  var isHTML = getNodeName(element) === 'html';\n  var winScrollBarX = getWindowScrollBarX(element);\n  var x = element.clientWidth + borders.right;\n  var y = element.clientHeight + borders.bottom; // HACK:\n  // document.documentElement.clientHeight on iOS reports the height of the\n  // viewport including the bottom bar, even if the bottom bar isn't visible.\n  // If the difference between window innerHeight and html clientHeight is more\n  // than 50, we assume it's a mobile bottom bar and ignore scrollbars.\n  // * A 50px thick scrollbar is likely non-existent (macOS is 15px and Windows\n  //   is about 17px)\n  // * The mobile bar is 114px tall\n\n  if (isHTML && win.innerHeight - element.clientHeight > 50) {\n    y = win.innerHeight - borders.bottom;\n  }\n\n  return {\n    top: isHTML ? 0 : element.clientTop,\n    right: // RTL scrollbar (scrolling containers only)\n    element.clientLeft > borders.left ? borders.right : // LTR scrollbar\n    isHTML ? win.innerWidth - x - winScrollBarX : element.offsetWidth - x,\n    bottom: isHTML ? win.innerHeight - y : element.offsetHeight - y,\n    left: isHTML ? winScrollBarX : element.clientLeft\n  };\n}","import \"core-js/modules/es6.object.assign\";\nexport default function rectToClientRect(rect) {\n  return Object.assign({}, rect, {\n    left: rect.x,\n    top: rect.y,\n    right: rect.x + rect.width,\n    bottom: rect.y + rect.height\n  });\n}","import { viewport } from \"../enums.js\";\nimport getViewportRect from \"./getViewportRect.js\";\nimport getDocumentRect from \"./getDocumentRect.js\";\nimport listScrollParents from \"./listScrollParents.js\";\nimport getOffsetParent from \"./getOffsetParent.js\";\nimport getDocumentElement from \"./getDocumentElement.js\";\nimport getComputedStyle from \"./getComputedStyle.js\";\nimport { isElement, isHTMLElement } from \"./instanceOf.js\";\nimport getBoundingClientRect from \"./getBoundingClientRect.js\";\nimport getDecorations from \"./getDecorations.js\";\nimport contains from \"./contains.js\";\nimport rectToClientRect from \"../utils/rectToClientRect.js\";\n\nfunction getClientRectFromMixedType(element, clippingParent) {\n  return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isHTMLElement(clippingParent) ? getBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element)));\n} // A \"clipping parent\" is an overflowable container with the characteristic of\n// clipping (or hiding) overflowing elements with a position different from\n// `initial`\n\n\nfunction getClippingParents(element) {\n  var clippingParents = listScrollParents(element);\n  var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle(element).position) >= 0;\n  var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;\n\n  if (!isElement(clipperElement)) {\n    return [];\n  } // $FlowFixMe: https://github.com/facebook/flow/issues/1414\n\n\n  return clippingParents.filter(function (clippingParent) {\n    return isElement(clippingParent) && contains(clippingParent, clipperElement);\n  });\n} // Gets the maximum area that the element is visible in due to any number of\n// clipping parents\n\n\nexport default function getClippingRect(element, boundary, rootBoundary) {\n  var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);\n  var clippingParents = [].concat(mainClippingParents, [rootBoundary]);\n  var firstClippingParent = clippingParents[0];\n  var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {\n    var rect = getClientRectFromMixedType(element, clippingParent);\n    var decorations = getDecorations(isHTMLElement(clippingParent) ? clippingParent : getDocumentElement(element));\n    accRect.top = Math.max(rect.top + decorations.top, accRect.top);\n    accRect.right = Math.min(rect.right - decorations.right, accRect.right);\n    accRect.bottom = Math.min(rect.bottom - decorations.bottom, accRect.bottom);\n    accRect.left = Math.max(rect.left + decorations.left, accRect.left);\n    return accRect;\n  }, getClientRectFromMixedType(element, firstClippingParent));\n  clippingRect.width = clippingRect.right - clippingRect.left;\n  clippingRect.height = clippingRect.bottom - clippingRect.top;\n  clippingRect.x = clippingRect.left;\n  clippingRect.y = clippingRect.top;\n  return clippingRect;\n}","import getWindow from \"./getWindow.js\";\nexport default function getViewportRect(element) {\n  var win = getWindow(element);\n  var visualViewport = win.visualViewport;\n  var width = win.innerWidth;\n  var height = win.innerHeight; // We don't know which browsers have buggy or odd implementations of this, so\n  // for now we're only applying it to iOS to fix the keyboard issue.\n  // Investigation required\n\n  if (visualViewport && /iPhone|iPod|iPad/.test(navigator.platform)) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n  }\n\n  return {\n    width: width,\n    height: height,\n    x: 0,\n    y: 0\n  };\n}","import getCompositeRect from \"./getCompositeRect.js\";\nimport getWindow from \"./getWindow.js\";\nimport getDocumentElement from \"./getDocumentElement.js\";\nimport getWindowScroll from \"./getWindowScroll.js\";\nexport default function getDocumentRect(element) {\n  var win = getWindow(element);\n  var winScroll = getWindowScroll(element);\n  var documentRect = getCompositeRect(getDocumentElement(element), win);\n  documentRect.height = Math.max(documentRect.height, win.innerHeight);\n  documentRect.width = Math.max(documentRect.width, win.innerWidth);\n  documentRect.x = -winScroll.scrollLeft;\n  documentRect.y = -winScroll.scrollTop;\n  return documentRect;\n}","import \"core-js/modules/es6.regexp.split\";\nexport default function getVariation(placement) {\n  return placement.split('-')[1];\n}","import getBasePlacement from \"./getBasePlacement.js\";\nimport getVariation from \"./getVariation.js\";\nimport getMainAxisFromPlacement from \"./getMainAxisFromPlacement.js\";\nimport { top, right, bottom, left, start, end } from \"../enums.js\";\nexport default function computeOffsets(_ref) {\n  var reference = _ref.reference,\n      element = _ref.element,\n      placement = _ref.placement;\n  var basePlacement = placement ? getBasePlacement(placement) : null;\n  var variation = placement ? getVariation(placement) : null;\n  var commonX = reference.x + reference.width / 2 - element.width / 2;\n  var commonY = reference.y + reference.height / 2 - element.height / 2;\n  var offsets;\n\n  switch (basePlacement) {\n    case top:\n      offsets = {\n        x: commonX,\n        y: reference.y - element.height\n      };\n      break;\n\n    case bottom:\n      offsets = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n\n    case right:\n      offsets = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n\n    case left:\n      offsets = {\n        x: reference.x - element.width,\n        y: commonY\n      };\n      break;\n\n    default:\n      offsets = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n\n  var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;\n\n  if (mainAxis != null) {\n    var len = mainAxis === 'y' ? 'height' : 'width';\n\n    switch (variation) {\n      case start:\n        offsets[mainAxis] = Math.floor(offsets[mainAxis]) - Math.floor(reference[len] / 2 - element[len] / 2);\n        break;\n\n      case end:\n        offsets[mainAxis] = Math.floor(offsets[mainAxis]) + Math.ceil(reference[len] / 2 - element[len] / 2);\n        break;\n\n      default:\n    }\n  }\n\n  return offsets;\n}","import \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.object.keys\";\nimport \"core-js/modules/es6.object.assign\";\nimport getBoundingClientRect from \"../dom-utils/getBoundingClientRect.js\";\nimport getClippingRect from \"../dom-utils/getClippingRect.js\";\nimport getDocumentElement from \"../dom-utils/getDocumentElement.js\";\nimport computeOffsets from \"./computeOffsets.js\";\nimport rectToClientRect from \"./rectToClientRect.js\";\nimport { clippingParents, reference, popper, bottom, top, right, basePlacements, viewport } from \"../enums.js\";\nimport { isElement } from \"../dom-utils/instanceOf.js\";\nimport mergePaddingObject from \"./mergePaddingObject.js\";\nimport expandToHashMap from \"./expandToHashMap.js\"; // eslint-disable-next-line import/no-unused-modules\n\nexport default function detectOverflow(state, options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options = options,\n      _options$placement = _options.placement,\n      placement = _options$placement === void 0 ? state.placement : _options$placement,\n      _options$boundary = _options.boundary,\n      boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,\n      _options$rootBoundary = _options.rootBoundary,\n      rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,\n      _options$elementConte = _options.elementContext,\n      elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,\n      _options$altBoundary = _options.altBoundary,\n      altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,\n      _options$padding = _options.padding,\n      padding = _options$padding === void 0 ? 0 : _options$padding;\n  var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));\n  var altContext = elementContext === popper ? reference : popper;\n  var referenceElement = state.elements.reference;\n  var popperRect = state.rects.popper;\n  var element = state.elements[altBoundary ? altContext : elementContext];\n  var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary);\n  var referenceClientRect = getBoundingClientRect(referenceElement);\n  var popperOffsets = computeOffsets({\n    reference: referenceClientRect,\n    element: popperRect,\n    strategy: 'absolute',\n    placement: placement\n  });\n  var popperClientRect = rectToClientRect(Object.assign({}, popperRect, {}, popperOffsets));\n  var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect\n  // 0 or negative = within the clipping rect\n\n  var overflowOffsets = {\n    top: clippingClientRect.top - elementClientRect.top + paddingObject.top,\n    bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,\n    left: clippingClientRect.left - elementClientRect.left + paddingObject.left,\n    right: elementClientRect.right - clippingClientRect.right + paddingObject.right\n  };\n  var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element\n\n  if (elementContext === popper && offsetData) {\n    var offset = offsetData[placement];\n    Object.keys(overflowOffsets).forEach(function (key) {\n      var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;\n      var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x';\n      overflowOffsets[key] += offset[axis] * multiply;\n    });\n  }\n\n  return overflowOffsets;\n}","import \"core-js/modules/es6.array.find\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.string.iterator\";\nimport \"core-js/modules/es6.map\";\nimport \"core-js/modules/es6.function.name\";\nimport getOppositePlacement from \"../utils/getOppositePlacement.js\";\nimport getBasePlacement from \"../utils/getBasePlacement.js\";\nimport getOppositeVariationPlacement from \"../utils/getOppositeVariationPlacement.js\";\nimport detectOverflow from \"../utils/detectOverflow.js\";\nimport computeAutoPlacement from \"../utils/computeAutoPlacement.js\";\nimport { bottom, top, start, right, left, auto } from \"../enums.js\";\nimport getVariation from \"../utils/getVariation.js\"; // eslint-disable-next-line import/no-unused-modules\n\nfunction getExpandedFallbackPlacements(placement) {\n  if (getBasePlacement(placement) === auto) {\n    return [];\n  }\n\n  var oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];\n}\n\nfunction flip(_ref) {\n  var state = _ref.state,\n      options = _ref.options,\n      name = _ref.name;\n\n  if (state.modifiersData[name]._skip) {\n    return;\n  }\n\n  var _options$mainAxis = options.mainAxis,\n      checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,\n      _options$altAxis = options.altAxis,\n      checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis,\n      specifiedFallbackPlacements = options.fallbackPlacements,\n      padding = options.padding,\n      boundary = options.boundary,\n      rootBoundary = options.rootBoundary,\n      altBoundary = options.altBoundary,\n      _options$flipVariatio = options.flipVariations,\n      flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio,\n      allowedAutoPlacements = options.allowedAutoPlacements;\n  var preferredPlacement = state.options.placement;\n  var basePlacement = getBasePlacement(preferredPlacement);\n  var isBasePlacement = basePlacement === preferredPlacement;\n  var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));\n  var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) {\n    return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, {\n      placement: placement,\n      boundary: boundary,\n      rootBoundary: rootBoundary,\n      padding: padding,\n      flipVariations: flipVariations,\n      allowedAutoPlacements: allowedAutoPlacements\n    }) : placement);\n  }, []);\n  var referenceRect = state.rects.reference;\n  var popperRect = state.rects.popper;\n  var checksMap = new Map();\n  var makeFallbackChecks = true;\n  var firstFittingPlacement = placements[0];\n\n  for (var i = 0; i < placements.length; i++) {\n    var placement = placements[i];\n\n    var _basePlacement = getBasePlacement(placement);\n\n    var isStartVariation = getVariation(placement) === start;\n    var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;\n    var len = isVertical ? 'width' : 'height';\n    var overflow = detectOverflow(state, {\n      placement: placement,\n      boundary: boundary,\n      rootBoundary: rootBoundary,\n      altBoundary: altBoundary,\n      padding: padding\n    });\n    var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;\n\n    if (referenceRect[len] > popperRect[len]) {\n      mainVariationSide = getOppositePlacement(mainVariationSide);\n    }\n\n    var altVariationSide = getOppositePlacement(mainVariationSide);\n    var checks = [];\n\n    if (checkMainAxis) {\n      checks.push(overflow[_basePlacement] <= 0);\n    }\n\n    if (checkAltAxis) {\n      checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);\n    }\n\n    if (checks.every(function (check) {\n      return check;\n    })) {\n      firstFittingPlacement = placement;\n      makeFallbackChecks = false;\n      break;\n    }\n\n    checksMap.set(placement, checks);\n  }\n\n  if (makeFallbackChecks) {\n    // `2` may be desired in some cases – research later\n    var numberOfChecks = flipVariations ? 3 : 1;\n\n    var _loop = function _loop(_i) {\n      var fittingPlacement = placements.find(function (placement) {\n        var checks = checksMap.get(placement);\n\n        if (checks) {\n          return checks.slice(0, _i).every(function (check) {\n            return check;\n          });\n        }\n      });\n\n      if (fittingPlacement) {\n        firstFittingPlacement = fittingPlacement;\n        return \"break\";\n      }\n    };\n\n    for (var _i = numberOfChecks; _i > 0; _i--) {\n      var _ret = _loop(_i);\n\n      if (_ret === \"break\") break;\n    }\n  }\n\n  if (state.placement !== firstFittingPlacement) {\n    state.modifiersData[name]._skip = true;\n    state.placement = firstFittingPlacement;\n    state.reset = true;\n  }\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n  name: 'flip',\n  enabled: true,\n  phase: 'main',\n  fn: flip,\n  requiresIfExists: ['offset'],\n  data: {\n    _skip: false\n  }\n};","import \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.object.keys\";\nimport getVariation from \"./getVariation.js\";\nimport { variationPlacements, basePlacements, placements as allPlacements } from \"../enums.js\";\nimport detectOverflow from \"./detectOverflow.js\";\nimport getBasePlacement from \"./getBasePlacement.js\";\n/*:: type OverflowsMap = { [ComputedPlacement]: number }; */\n\n/*;; type OverflowsMap = { [key in ComputedPlacement]: number }; */\n\nexport default function computeAutoPlacement(state, options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options = options,\n      placement = _options.placement,\n      boundary = _options.boundary,\n      rootBoundary = _options.rootBoundary,\n      padding = _options.padding,\n      flipVariations = _options.flipVariations,\n      _options$allowedAutoP = _options.allowedAutoPlacements,\n      allowedAutoPlacements = _options$allowedAutoP === void 0 ? allPlacements : _options$allowedAutoP;\n  var variation = getVariation(placement);\n  var placements = (variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) {\n    return getVariation(placement) === variation;\n  }) : basePlacements).filter(function (placement) {\n    return allowedAutoPlacements.indexOf(placement) >= 0;\n  }); // $FlowFixMe: Flow seems to have problems with two array unions...\n\n  var overflows = placements.reduce(function (acc, placement) {\n    acc[placement] = detectOverflow(state, {\n      placement: placement,\n      boundary: boundary,\n      rootBoundary: rootBoundary,\n      padding: padding\n    })[getBasePlacement(placement)];\n    return acc;\n  }, {});\n  return Object.keys(overflows).sort(function (a, b) {\n    return overflows[a] - overflows[b];\n  });\n}","import \"core-js/modules/es6.object.assign\";\nimport \"core-js/modules/es6.function.name\";\nimport { top, bottom, left, right } from \"../enums.js\";\nimport detectOverflow from \"../utils/detectOverflow.js\";\n\nfunction getSideOffsets(overflow, rect, preventedOffsets) {\n  if (preventedOffsets === void 0) {\n    preventedOffsets = {\n      x: 0,\n      y: 0\n    };\n  }\n\n  return {\n    top: overflow.top - rect.height - preventedOffsets.y,\n    right: overflow.right - rect.width + preventedOffsets.x,\n    bottom: overflow.bottom - rect.height + preventedOffsets.y,\n    left: overflow.left - rect.width - preventedOffsets.x\n  };\n}\n\nfunction isAnySideFullyClipped(overflow) {\n  return [top, right, bottom, left].some(function (side) {\n    return overflow[side] >= 0;\n  });\n}\n\nfunction hide(_ref) {\n  var state = _ref.state,\n      name = _ref.name;\n  var referenceRect = state.rects.reference;\n  var popperRect = state.rects.popper;\n  var preventedOffsets = state.modifiersData.preventOverflow;\n  var referenceOverflow = detectOverflow(state, {\n    elementContext: 'reference'\n  });\n  var popperAltOverflow = detectOverflow(state, {\n    altBoundary: true\n  });\n  var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);\n  var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);\n  var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);\n  var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);\n  state.modifiersData[name] = {\n    referenceClippingOffsets: referenceClippingOffsets,\n    popperEscapeOffsets: popperEscapeOffsets,\n    isReferenceHidden: isReferenceHidden,\n    hasPopperEscaped: hasPopperEscaped\n  };\n  state.attributes.popper = Object.assign({}, state.attributes.popper, {\n    'data-popper-reference-hidden': isReferenceHidden,\n    'data-popper-escaped': hasPopperEscaped\n  });\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n  name: 'hide',\n  enabled: true,\n  phase: 'main',\n  requiresIfExists: ['preventOverflow'],\n  fn: hide\n};","import \"core-js/modules/es6.function.name\";\nimport \"core-js/modules/es6.object.assign\";\nimport getBasePlacement from \"../utils/getBasePlacement.js\";\nimport { top, left, right, placements } from \"../enums.js\";\nexport function distanceAndSkiddingToXY(placement, rects, offset) {\n  var basePlacement = getBasePlacement(placement);\n  var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;\n\n  var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, {\n    placement: placement\n  })) : offset,\n      skidding = _ref[0],\n      distance = _ref[1];\n\n  skidding = skidding || 0;\n  distance = (distance || 0) * invertDistance;\n  return [left, right].indexOf(basePlacement) >= 0 ? {\n    x: distance,\n    y: skidding\n  } : {\n    x: skidding,\n    y: distance\n  };\n}\n\nfunction offset(_ref2) {\n  var state = _ref2.state,\n      options = _ref2.options,\n      name = _ref2.name;\n  var _options$offset = options.offset,\n      offset = _options$offset === void 0 ? [0, 0] : _options$offset;\n  var data = placements.reduce(function (acc, placement) {\n    acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);\n    return acc;\n  }, {});\n  var _data$state$placement = data[state.placement],\n      x = _data$state$placement.x,\n      y = _data$state$placement.y;\n\n  if (state.modifiersData.popperOffsets != null) {\n    state.modifiersData.popperOffsets.x += x;\n    state.modifiersData.popperOffsets.y += y;\n  }\n\n  state.modifiersData[name] = data;\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n  name: 'offset',\n  enabled: true,\n  phase: 'main',\n  requires: ['popperOffsets'],\n  fn: offset\n};","import \"core-js/modules/es6.function.name\";\nimport computeOffsets from \"../utils/computeOffsets.js\";\n\nfunction popperOffsets(_ref) {\n  var state = _ref.state,\n      name = _ref.name; // Offsets are the actual position the popper needs to have to be\n  // properly positioned near its reference element\n  // This is the most basic placement, and will be adjusted by\n  // the modifiers in the next step\n\n  state.modifiersData[name] = computeOffsets({\n    reference: state.rects.reference,\n    element: state.rects.popper,\n    strategy: 'absolute',\n    placement: state.placement\n  });\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n  name: 'popperOffsets',\n  enabled: true,\n  phase: 'read',\n  fn: popperOffsets,\n  data: {}\n};","import \"core-js/modules/es6.object.assign\";\nimport \"core-js/modules/es6.function.name\";\nimport { top, left, right, bottom, start } from \"../enums.js\";\nimport getBasePlacement from \"../utils/getBasePlacement.js\";\nimport getMainAxisFromPlacement from \"../utils/getMainAxisFromPlacement.js\";\nimport getAltAxis from \"../utils/getAltAxis.js\";\nimport within from \"../utils/within.js\";\nimport getLayoutRect from \"../dom-utils/getLayoutRect.js\";\nimport getOffsetParent from \"../dom-utils/getOffsetParent.js\";\nimport detectOverflow from \"../utils/detectOverflow.js\";\nimport getVariation from \"../utils/getVariation.js\";\nimport getFreshSideObject from \"../utils/getFreshSideObject.js\";\n\nfunction preventOverflow(_ref) {\n  var state = _ref.state,\n      options = _ref.options,\n      name = _ref.name;\n  var _options$mainAxis = options.mainAxis,\n      checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,\n      _options$altAxis = options.altAxis,\n      checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis,\n      boundary = options.boundary,\n      rootBoundary = options.rootBoundary,\n      altBoundary = options.altBoundary,\n      padding = options.padding,\n      _options$tether = options.tether,\n      tether = _options$tether === void 0 ? true : _options$tether,\n      _options$tetherOffset = options.tetherOffset,\n      tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;\n  var overflow = detectOverflow(state, {\n    boundary: boundary,\n    rootBoundary: rootBoundary,\n    padding: padding,\n    altBoundary: altBoundary\n  });\n  var basePlacement = getBasePlacement(state.placement);\n  var variation = getVariation(state.placement);\n  var isBasePlacement = !variation;\n  var mainAxis = getMainAxisFromPlacement(basePlacement);\n  var altAxis = getAltAxis(mainAxis);\n  var popperOffsets = state.modifiersData.popperOffsets;\n  var referenceRect = state.rects.reference;\n  var popperRect = state.rects.popper;\n  var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, {\n    placement: state.placement\n  })) : tetherOffset;\n  var data = {\n    x: 0,\n    y: 0\n  };\n\n  if (!popperOffsets) {\n    return;\n  }\n\n  if (checkMainAxis) {\n    var mainSide = mainAxis === 'y' ? top : left;\n    var altSide = mainAxis === 'y' ? bottom : right;\n    var len = mainAxis === 'y' ? 'height' : 'width';\n    var offset = popperOffsets[mainAxis];\n    var min = popperOffsets[mainAxis] + overflow[mainSide];\n    var max = popperOffsets[mainAxis] - overflow[altSide];\n    var additive = tether ? -popperRect[len] / 2 : 0;\n    var minLen = variation === start ? referenceRect[len] : popperRect[len];\n    var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go\n    // outside the reference bounds\n\n    var arrowElement = state.elements.arrow;\n    var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {\n      width: 0,\n      height: 0\n    };\n    var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject();\n    var arrowPaddingMin = arrowPaddingObject[mainSide];\n    var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want\n    // to include its full size in the calculation. If the reference is small\n    // and near the edge of a boundary, the popper can overflow even if the\n    // reference is not overflowing as well (e.g. virtual elements with no\n    // width or height)\n\n    var arrowLen = within(0, referenceRect[len], arrowRect[len]);\n    var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - tetherOffsetValue : minLen - arrowLen - arrowPaddingMin - tetherOffsetValue;\n    var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + tetherOffsetValue : maxLen + arrowLen + arrowPaddingMax + tetherOffsetValue;\n    var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);\n    var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;\n    var offsetModifierValue = state.modifiersData.offset ? state.modifiersData.offset[state.placement][mainAxis] : 0;\n    var tetherMin = popperOffsets[mainAxis] + minOffset - offsetModifierValue - clientOffset;\n    var tetherMax = popperOffsets[mainAxis] + maxOffset - offsetModifierValue;\n    var preventedOffset = within(tether ? Math.min(min, tetherMin) : min, offset, tether ? Math.max(max, tetherMax) : max);\n    popperOffsets[mainAxis] = preventedOffset;\n    data[mainAxis] = preventedOffset - offset;\n  }\n\n  if (checkAltAxis) {\n    var _mainSide = mainAxis === 'x' ? top : left;\n\n    var _altSide = mainAxis === 'x' ? bottom : right;\n\n    var _offset = popperOffsets[altAxis];\n\n    var _min = _offset + overflow[_mainSide];\n\n    var _max = _offset - overflow[_altSide];\n\n    var _preventedOffset = within(_min, _offset, _max);\n\n    popperOffsets[altAxis] = _preventedOffset;\n    data[altAxis] = _preventedOffset - _offset;\n  }\n\n  state.modifiersData[name] = data;\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n  name: 'preventOverflow',\n  enabled: true,\n  phase: 'main',\n  fn: preventOverflow,\n  requiresIfExists: ['offset']\n};","export default function getAltAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}","import \"core-js/modules/es6.function.name\";\nimport \"core-js/modules/es6.set\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.string.iterator\";\nimport \"core-js/modules/es6.map\";\nimport { modifierPhases } from \"../enums.js\"; // source: https://stackoverflow.com/questions/49875255\n\nfunction order(modifiers) {\n  var map = new Map();\n  var visited = new Set();\n  var result = [];\n  modifiers.forEach(function (modifier) {\n    map.set(modifier.name, modifier);\n  }); // On visiting object, check for its dependencies and visit them recursively\n\n  function sort(modifier) {\n    visited.add(modifier.name);\n    var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);\n    requires.forEach(function (dep) {\n      if (!visited.has(dep)) {\n        var depModifier = map.get(dep);\n\n        if (depModifier) {\n          sort(depModifier);\n        }\n      }\n    });\n    result.push(modifier);\n  }\n\n  modifiers.forEach(function (modifier) {\n    if (!visited.has(modifier.name)) {\n      // check for visited object\n      sort(modifier);\n    }\n  });\n  return result;\n}\n\nexport default function orderModifiers(modifiers) {\n  // order based on dependencies\n  var orderedModifiers = order(modifiers); // order based on phase\n\n  return modifierPhases.reduce(function (acc, phase) {\n    return acc.concat(orderedModifiers.filter(function (modifier) {\n      return modifier.phase === phase;\n    }));\n  }, []);\n}","import \"core-js/modules/es6.promise\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.array.find\";\nimport \"core-js/modules/es6.function.name\";\nimport \"core-js/modules/es6.object.assign\";\nimport getCompositeRect from \"./dom-utils/getCompositeRect.js\";\nimport getLayoutRect from \"./dom-utils/getLayoutRect.js\";\nimport listScrollParents from \"./dom-utils/listScrollParents.js\";\nimport getOffsetParent from \"./dom-utils/getOffsetParent.js\";\nimport getComputedStyle from \"./dom-utils/getComputedStyle.js\";\nimport orderModifiers from \"./utils/orderModifiers.js\";\nimport debounce from \"./utils/debounce.js\";\nimport validateModifiers from \"./utils/validateModifiers.js\";\nimport uniqueBy from \"./utils/uniqueBy.js\";\nimport getBasePlacement from \"./utils/getBasePlacement.js\";\nimport mergeByName from \"./utils/mergeByName.js\";\nimport { isElement } from \"./dom-utils/instanceOf.js\";\nimport { auto } from \"./enums.js\";\nexport * from \"./enums.js\";\nvar INVALID_ELEMENT_ERROR = 'Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.';\nvar INFINITE_LOOP_ERROR = 'Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.';\nvar DEFAULT_OPTIONS = {\n  placement: 'bottom',\n  modifiers: [],\n  strategy: 'absolute'\n};\n\nfunction areValidElements() {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  return !args.some(function (element) {\n    return !(element && typeof element.getBoundingClientRect === 'function');\n  });\n}\n\nexport function popperGenerator(generatorOptions) {\n  if (generatorOptions === void 0) {\n    generatorOptions = {};\n  }\n\n  var _generatorOptions = generatorOptions,\n      _generatorOptions$def = _generatorOptions.defaultModifiers,\n      defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def,\n      _generatorOptions$def2 = _generatorOptions.defaultOptions,\n      defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;\n  return function createPopper(reference, popper, options) {\n    if (options === void 0) {\n      options = defaultOptions;\n    }\n\n    var state = {\n      placement: 'bottom',\n      orderedModifiers: [],\n      options: Object.assign({}, DEFAULT_OPTIONS, {}, defaultOptions),\n      modifiersData: {},\n      elements: {\n        reference: reference,\n        popper: popper\n      },\n      attributes: {},\n      styles: {}\n    };\n    var effectCleanupFns = [];\n    var isDestroyed = false;\n    var instance = {\n      state: state,\n      setOptions: function setOptions(options) {\n        cleanupModifierEffects();\n        state.options = Object.assign({}, defaultOptions, {}, state.options, {}, options);\n        state.scrollParents = {\n          reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],\n          popper: listScrollParents(popper)\n        }; // Orders the modifiers based on their dependencies and `phase`\n        // properties\n\n        var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers\n\n        state.orderedModifiers = orderedModifiers.filter(function (m) {\n          return m.enabled;\n        }); // Validate the provided modifiers so that the consumer will get warned\n        // if one of the modifiers is invalid for any reason\n\n        if (process.env.NODE_ENV !== \"production\") {\n          var modifiers = uniqueBy([].concat(orderedModifiers, state.options.modifiers), function (_ref) {\n            var name = _ref.name;\n            return name;\n          });\n          validateModifiers(modifiers);\n\n          if (getBasePlacement(state.options.placement) === auto) {\n            var flipModifier = state.orderedModifiers.find(function (_ref2) {\n              var name = _ref2.name;\n              return name === 'flip';\n            });\n\n            if (!flipModifier) {\n              console.error(['Popper: \"auto\" placements require the \"flip\" modifier be', 'present and enabled to work.'].join(' '));\n            }\n          }\n\n          var _getComputedStyle = getComputedStyle(popper),\n              marginTop = _getComputedStyle.marginTop,\n              marginRight = _getComputedStyle.marginRight,\n              marginBottom = _getComputedStyle.marginBottom,\n              marginLeft = _getComputedStyle.marginLeft; // We no longer take into account `margins` on the popper, and it can\n          // cause bugs with positioning, so we'll warn the consumer\n\n\n          if ([marginTop, marginRight, marginBottom, marginLeft].some(function (margin) {\n            return parseFloat(margin);\n          })) {\n            console.warn(['Popper: CSS \"margin\" styles cannot be used to apply padding', 'between the popper and its reference element or boundary.', 'To replicate margin, use the `offset` modifier, as well as', 'the `padding` option in the `preventOverflow` and `flip`', 'modifiers.'].join(' '));\n          }\n        }\n\n        runModifierEffects();\n        return instance.update();\n      },\n      // Sync update – it will always be executed, even if not necessary. This\n      // is useful for low frequency updates where sync behavior simplifies the\n      // logic.\n      // For high frequency updates (e.g. `resize` and `scroll` events), always\n      // prefer the async Popper#update method\n      forceUpdate: function forceUpdate() {\n        if (isDestroyed) {\n          return;\n        }\n\n        var _state$elements = state.elements,\n            reference = _state$elements.reference,\n            popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements\n        // anymore\n\n        if (!areValidElements(reference, popper)) {\n          if (process.env.NODE_ENV !== \"production\") {\n            console.error(INVALID_ELEMENT_ERROR);\n          }\n\n          return;\n        } // Store the reference and popper rects to be read by modifiers\n\n\n        state.rects = {\n          reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'),\n          popper: getLayoutRect(popper)\n        }; // Modifiers have the ability to reset the current update cycle. The\n        // most common use case for this is the `flip` modifier changing the\n        // placement, which then needs to re-run all the modifiers, because the\n        // logic was previously ran for the previous placement and is therefore\n        // stale/incorrect\n\n        state.reset = false;\n        state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier\n        // is filled with the initial data specified by the modifier. This means\n        // it doesn't persist and is fresh on each update.\n        // To ensure persistent data, use `${name}#persistent`\n\n        state.orderedModifiers.forEach(function (modifier) {\n          return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);\n        });\n        var __debug_loops__ = 0;\n\n        for (var index = 0; index < state.orderedModifiers.length; index++) {\n          if (process.env.NODE_ENV !== \"production\") {\n            __debug_loops__ += 1;\n\n            if (__debug_loops__ > 100) {\n              console.error(INFINITE_LOOP_ERROR);\n              break;\n            }\n          }\n\n          if (state.reset === true) {\n            state.reset = false;\n            index = -1;\n            continue;\n          }\n\n          var _state$orderedModifie = state.orderedModifiers[index],\n              fn = _state$orderedModifie.fn,\n              _state$orderedModifie2 = _state$orderedModifie.options,\n              _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2,\n              name = _state$orderedModifie.name;\n\n          if (typeof fn === 'function') {\n            state = fn({\n              state: state,\n              options: _options,\n              name: name,\n              instance: instance\n            }) || state;\n          }\n        }\n      },\n      // Async and optimistically optimized update – it will not be executed if\n      // not necessary (debounced to run at most once-per-tick)\n      update: debounce(function () {\n        return new Promise(function (resolve) {\n          instance.forceUpdate();\n          resolve(state);\n        });\n      }),\n      destroy: function destroy() {\n        cleanupModifierEffects();\n        isDestroyed = true;\n      }\n    };\n\n    if (!areValidElements(reference, popper)) {\n      if (process.env.NODE_ENV !== \"production\") {\n        console.error(INVALID_ELEMENT_ERROR);\n      }\n\n      return instance;\n    }\n\n    instance.setOptions(options).then(function (state) {\n      if (!isDestroyed && options.onFirstUpdate) {\n        options.onFirstUpdate(state);\n      }\n    }); // Modifiers have the ability to execute arbitrary code before the first\n    // update cycle runs. They will be executed in the same order as the update\n    // cycle. This is useful when a modifier adds some persistent data that\n    // other modifiers need to use, but the modifier is run after the dependent\n    // one.\n\n    function runModifierEffects() {\n      state.orderedModifiers.forEach(function (_ref3) {\n        var name = _ref3.name,\n            _ref3$options = _ref3.options,\n            options = _ref3$options === void 0 ? {} : _ref3$options,\n            effect = _ref3.effect;\n\n        if (typeof effect === 'function') {\n          var cleanupFn = effect({\n            state: state,\n            name: name,\n            instance: instance,\n            options: options\n          });\n\n          var noopFn = function noopFn() {};\n\n          effectCleanupFns.push(cleanupFn || noopFn);\n        }\n      });\n    }\n\n    function cleanupModifierEffects() {\n      effectCleanupFns.forEach(function (fn) {\n        return fn();\n      });\n      effectCleanupFns = [];\n    }\n\n    return instance;\n  };\n}\nexport var createPopper = /*#__PURE__*/popperGenerator();","import \"core-js/modules/es6.promise\";\nimport \"core-js/modules/es6.object.to-string\";\nexport default function debounce(fn) {\n  var pending;\n  return function () {\n    if (!pending) {\n      pending = new Promise(function (resolve) {\n        Promise.resolve().then(function () {\n          pending = undefined;\n          resolve(fn());\n        });\n      });\n    }\n\n    return pending;\n  };\n}","import \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.object.keys\";\nimport \"core-js/modules/es6.object.assign\";\nimport \"core-js/modules/es6.function.name\";\nexport default function mergeByName(modifiers) {\n  var merged = modifiers.reduce(function (merged, current) {\n    var existing = merged[current.name];\n    merged[current.name] = existing ? Object.assign({}, existing, {}, current, {\n      options: Object.assign({}, existing.options, {}, current.options),\n      data: Object.assign({}, existing.data, {}, current.data)\n    }) : current;\n    return merged;\n  }, {}); // IE11 does not support Object.values\n\n  return Object.keys(merged).map(function (key) {\n    return merged[key];\n  });\n}","import arrow from '@popperjs/core/lib/modifiers/arrow';\nimport computeStyles from '@popperjs/core/lib/modifiers/computeStyles';\nimport eventListeners from '@popperjs/core/lib/modifiers/eventListeners';\nimport flip from '@popperjs/core/lib/modifiers/flip';\nimport hide from '@popperjs/core/lib/modifiers/hide';\nimport offset from '@popperjs/core/lib/modifiers/offset';\nimport popperOffsets from '@popperjs/core/lib/modifiers/popperOffsets';\nimport preventOverflow from '@popperjs/core/lib/modifiers/preventOverflow';\nimport { placements } from '@popperjs/core/lib/enums';\nimport { popperGenerator } from '@popperjs/core/lib/popper-base'; // For the common JS build we will turn this file into a bundle with no imports.\n// This is b/c the Popper lib is all esm files, and would break in a common js only environment\n\nexport var createPopper = popperGenerator({\n  defaultModifiers: [hide, popperOffsets, computeStyles, eventListeners, offset, flip, preventOverflow, arrow]\n});\nexport { placements };","import { useMemo, useRef } from 'react';\nimport useMounted from './useMounted';\nimport useWillUnmount from './useWillUnmount';\n/*\n * Browsers including Internet Explorer, Chrome, Safari, and Firefox store the\n * delay as a 32-bit signed integer internally. This causes an integer overflow\n * when using delays larger than 2,147,483,647 ms (about 24.8 days),\n * resulting in the timeout being executed immediately.\n *\n * via: https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout\n */\n\nvar MAX_DELAY_MS = Math.pow(2, 31) - 1;\n\nfunction setChainedTimeout(handleRef, fn, timeoutAtMs) {\n  var delayMs = timeoutAtMs - Date.now();\n  handleRef.current = delayMs <= MAX_DELAY_MS ? setTimeout(fn, delayMs) : setTimeout(function () {\n    return setChainedTimeout(handleRef, fn, timeoutAtMs);\n  }, MAX_DELAY_MS);\n}\n/**\n * Returns a controller object for setting a timeout that is properly cleaned up\n * once the component unmounts. New timeouts cancel and replace existing ones.\n */\n\n\nexport default function useTimeout() {\n  var isMounted = useMounted(); // types are confused between node and web here IDK\n\n  var handleRef = useRef();\n  useWillUnmount(function () {\n    return clearTimeout(handleRef.current);\n  });\n  return useMemo(function () {\n    var clear = function clear() {\n      return clearTimeout(handleRef.current);\n    };\n\n    function set(fn, delayMs) {\n      if (delayMs === void 0) {\n        delayMs = 0;\n      }\n\n      if (!isMounted()) return;\n      clear();\n\n      if (delayMs <= MAX_DELAY_MS) {\n        // For simplicity, if the timeout is short, just set a normal timeout.\n        handleRef.current = setTimeout(fn, delayMs);\n      } else {\n        setChainedTimeout(handleRef, fn, Date.now() + delayMs);\n      }\n    }\n\n    return {\n      set: set,\n      clear: clear\n    };\n  }, []);\n}","import { useMemo } from 'react';\n\nvar toFnRef = function toFnRef(ref) {\n  return !ref || typeof ref === 'function' ? ref : function (value) {\n    ref.current = value;\n  };\n};\n\nexport function mergeRefs(refA, refB) {\n  var a = toFnRef(refA);\n  var b = toFnRef(refB);\n  return function (value) {\n    if (a) a(value);\n    if (b) b(value);\n  };\n}\n/**\n * Create and returns a single callback ref composed from two other Refs.\n *\n * ```tsx\n * const Button = React.forwardRef((props, ref) => {\n *   const [element, attachRef] = useCallbackRef<HTMLButtonElement>();\n *   const mergedRef = useMergedRefs(ref, attachRef);\n *\n *   return <button ref={mergedRef} {...props}/>\n * })\n * ```\n *\n * @param refA A Callback or mutable Ref\n * @param refB A Callback or mutable Ref\n * @category refs\n */\n\nfunction useMergedRefs(refA, refB) {\n  return useMemo(function () {\n    return mergeRefs(refA, refB);\n  }, [refA, refB]);\n}\n\nexport default useMergedRefs;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport PropTypes from 'prop-types';\nimport React, { useState } from 'react';\nimport ReactDOM from 'react-dom';\nimport useCallbackRef from '@restart/hooks/useCallbackRef';\nimport useMergedRefs from '@restart/hooks/useMergedRefs';\nimport { placements } from './popper';\nimport usePopper, { toModifierMap } from './usePopper';\nimport useRootClose from './useRootClose';\nimport useWaitForDOMRef from './useWaitForDOMRef';\n/**\n * Built on top of `Popper.js`, the overlay component is\n * great for custom tooltip overlays.\n */\n\nvar Overlay = React.forwardRef(function (props, outerRef) {\n  var _modifiers$preventOve, _modifiers$arrow;\n\n  var flip = props.flip,\n      placement = props.placement,\n      _props$containerPaddi = props.containerPadding,\n      containerPadding = _props$containerPaddi === void 0 ? 5 : _props$containerPaddi,\n      _props$popperConfig = props.popperConfig,\n      popperConfig = _props$popperConfig === void 0 ? {} : _props$popperConfig,\n      Transition = props.transition;\n\n  var _useCallbackRef = useCallbackRef(),\n      rootElement = _useCallbackRef[0],\n      attachRef = _useCallbackRef[1];\n\n  var _useCallbackRef2 = useCallbackRef(),\n      arrowElement = _useCallbackRef2[0],\n      attachArrowRef = _useCallbackRef2[1];\n\n  var mergedRef = useMergedRefs(attachRef, outerRef);\n  var container = useWaitForDOMRef(props.container);\n  var target = useWaitForDOMRef(props.target);\n\n  var _useState = useState(!props.show),\n      exited = _useState[0],\n      setExited = _useState[1];\n\n  var modifiers = toModifierMap(popperConfig.modifiers);\n\n  var _usePopper = usePopper(target, rootElement, _extends({}, popperConfig, {\n    placement: placement || 'bottom',\n    modifiers: _extends({}, modifiers, {\n      eventListeners: {\n        enabled: !!props.show\n      },\n      preventOverflow: _extends({}, modifiers.preventOverflow, {\n        options: _extends({\n          padding: containerPadding || 5\n        }, (_modifiers$preventOve = modifiers.preventOverflow) == null ? void 0 : _modifiers$preventOve.options)\n      }),\n      arrow: _extends({}, modifiers.arrow, {\n        enabled: !!arrowElement,\n        options: _extends({}, (_modifiers$arrow = modifiers.arrow) == null ? void 0 : _modifiers$arrow.options, {\n          element: arrowElement\n        })\n      }),\n      flip: _extends({\n        enabled: !!flip\n      }, modifiers.flip)\n    })\n  })),\n      styles = _usePopper.styles,\n      arrowStyles = _usePopper.arrowStyles,\n      popper = _objectWithoutPropertiesLoose(_usePopper, [\"styles\", \"arrowStyles\"]);\n\n  if (props.show) {\n    if (exited) setExited(false);\n  } else if (!props.transition && !exited) {\n    setExited(true);\n  }\n\n  var handleHidden = function handleHidden() {\n    setExited(true);\n\n    if (props.onExited) {\n      props.onExited.apply(props, arguments);\n    }\n  }; // Don't un-render the overlay while it's transitioning out.\n\n\n  var mountOverlay = props.show || Transition && !exited;\n  useRootClose(rootElement, props.onHide, {\n    disabled: !props.rootClose || props.rootCloseDisabled,\n    clickTrigger: props.rootCloseEvent\n  });\n\n  if (!mountOverlay) {\n    // Don't bother showing anything if we don't have to.\n    return null;\n  }\n\n  var child = props.children(_extends({}, popper, {\n    show: !!props.show,\n    props: {\n      style: styles,\n      ref: mergedRef\n    },\n    arrowProps: {\n      style: arrowStyles,\n      ref: attachArrowRef\n    }\n  }));\n\n  if (Transition) {\n    var onExit = props.onExit,\n        onExiting = props.onExiting,\n        onEnter = props.onEnter,\n        onEntering = props.onEntering,\n        onEntered = props.onEntered;\n    child = /*#__PURE__*/React.createElement(Transition, {\n      \"in\": props.show,\n      appear: true,\n      onExit: onExit,\n      onExiting: onExiting,\n      onExited: handleHidden,\n      onEnter: onEnter,\n      onEntering: onEntering,\n      onEntered: onEntered\n    }, child);\n  }\n\n  return container ? ReactDOM.createPortal(child, container) : null;\n});\nOverlay.displayName = 'Overlay';\nOverlay.propTypes = {\n  /**\n   * Set the visibility of the Overlay\n   */\n  show: PropTypes.bool,\n\n  /** Specify where the overlay element is positioned in relation to the target element */\n  placement: PropTypes.oneOf(placements),\n\n  /**\n   * A DOM Element, Ref to an element, or function that returns either. The `target` element is where\n   * the overlay is positioned relative to.\n   */\n  target: PropTypes.any,\n\n  /**\n   * A DOM Element, Ref to an element, or function that returns either. The `container` will have the Portal children\n   * appended to it.\n   */\n  container: PropTypes.any,\n\n  /**\n   * Enables the Popper.js `flip` modifier, allowing the Overlay to\n   * automatically adjust it's placement in case of overlap with the viewport or toggle.\n   * Refer to the [flip docs](https://popper.js.org/popper-documentation.html#modifiers..flip.enabled) for more info\n   */\n  flip: PropTypes.bool,\n\n  /**\n   * A render prop that returns an element to overlay and position. See\n   * the [react-popper documentation](https://github.com/FezVrasta/react-popper#children) for more info.\n   *\n   * @type {Function ({\n   *   show: boolean,\n   *   placement: Placement,\n   *   outOfBoundaries: ?boolean,\n   *   scheduleUpdate: () => void,\n   *   props: {\n   *     ref: (?HTMLElement) => void,\n   *     style: { [string]: string | number },\n   *     aria-labelledby: ?string\n   *   },\n   *   arrowProps: {\n   *     ref: (?HTMLElement) => void,\n   *     style: { [string]: string | number },\n   *   },\n   * }) => React.Element}\n   */\n  children: PropTypes.func.isRequired,\n\n  /**\n   * Control how much space there is between the edge of the boundary element and overlay.\n   * A convenience shortcut to setting `popperConfig.modfiers.preventOverflow.padding`\n   */\n  containerPadding: PropTypes.number,\n\n  /**\n   * A set of popper options and props passed directly to react-popper's Popper component.\n   */\n  popperConfig: PropTypes.object,\n\n  /**\n   * Specify whether the overlay should trigger `onHide` when the user clicks outside the overlay\n   */\n  rootClose: PropTypes.bool,\n\n  /**\n   * Specify event for toggling overlay\n   */\n  rootCloseEvent: PropTypes.oneOf(['click', 'mousedown']),\n\n  /**\n   * Specify disabled for disable RootCloseWrapper\n   */\n  rootCloseDisabled: PropTypes.bool,\n\n  /**\n   * A Callback fired by the Overlay when it wishes to be hidden.\n   *\n   * __required__ when `rootClose` is `true`.\n   *\n   * @type func\n   */\n  onHide: function onHide(props) {\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    if (props.rootClose) {\n      var _PropTypes$func;\n\n      return (_PropTypes$func = PropTypes.func).isRequired.apply(_PropTypes$func, [props].concat(args));\n    }\n\n    return PropTypes.func.apply(PropTypes, [props].concat(args));\n  },\n\n  /**\n   * A `react-transition-group@2.0.0` `<Transition/>` component\n   * used to animate the overlay as it changes visibility.\n   */\n  // @ts-ignore\n  transition: PropTypes.elementType,\n\n  /**\n   * Callback fired before the Overlay transitions in\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * Callback fired as the Overlay begins to transition in\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * Callback fired after the Overlay finishes transitioning in\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * Callback fired right before the Overlay transitions out\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * Callback fired as the Overlay begins to transition out\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * Callback fired after the Overlay finishes transitioning out\n   */\n  onExited: PropTypes.func\n};\nexport default Overlay;","export default function hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);\n  return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}","import \"core-js/modules/es6.regexp.split\";\nimport { useCallback, useRef, useMemo } from 'react';\nimport hasClass from 'dom-helpers/hasClass';\n\nfunction getMargins(element) {\n  var styles = getComputedStyle(element);\n  var top = parseFloat(styles.marginTop) || 0;\n  var right = parseFloat(styles.marginRight) || 0;\n  var bottom = parseFloat(styles.marginBottom) || 0;\n  var left = parseFloat(styles.marginLeft) || 0;\n  return {\n    top: top,\n    right: right,\n    bottom: bottom,\n    left: left\n  };\n}\n\nexport default function usePopperMarginModifiers() {\n  var overlayRef = useRef(null);\n  var margins = useRef(null);\n  return [useCallback(function (overlay) {\n    if (!overlay || !(hasClass(overlay, 'popover') || hasClass(overlay, 'dropdown-menu'))) return;\n    margins.current = getMargins(overlay);\n    overlay.style.margin = 0;\n    overlayRef.current = overlay;\n  }, []), [useMemo(function () {\n    return {\n      name: 'offset',\n      options: {\n        offset: function offset(_ref) {\n          var placement = _ref.placement;\n          if (!margins.current) return [0, 0];\n          var _margins$current = margins.current,\n              top = _margins$current.top,\n              left = _margins$current.left,\n              bottom = _margins$current.bottom,\n              right = _margins$current.right;\n\n          switch (placement.split('-')[0]) {\n            case 'top':\n              return [0, bottom];\n\n            case 'left':\n              return [0, right];\n\n            case 'bottom':\n              return [0, top];\n\n            case 'right':\n              return [0, left];\n\n            default:\n              return [0, 0];\n          }\n        }\n      }\n    };\n  }, [margins])]];\n}","import \"core-js/modules/es6.object.assign\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport React, { useRef } from 'react';\nimport classNames from 'classnames';\nimport BaseOverlay from 'react-overlays/Overlay';\nimport safeFindDOMNode from 'react-overlays/safeFindDOMNode';\nimport usePopperMarginModifiers from './usePopperMarginModifiers';\nimport Fade from './Fade';\nvar defaultProps = {\n  transition: Fade,\n  rootClose: false,\n  show: false,\n  placement: 'top'\n};\n\nfunction wrapRefs(props, arrowProps) {\n  var ref = props.ref;\n  var aRef = arrowProps.ref;\n\n  props.ref = ref.__wrapped || (ref.__wrapped = function (r) {\n    return ref(safeFindDOMNode(r));\n  });\n\n  arrowProps.ref = aRef.__wrapped || (aRef.__wrapped = function (r) {\n    return aRef(safeFindDOMNode(r));\n  });\n}\n\nfunction Overlay(_ref) {\n  var overlay = _ref.children,\n      transition = _ref.transition,\n      _ref$popperConfig = _ref.popperConfig,\n      popperConfig = _ref$popperConfig === void 0 ? {} : _ref$popperConfig,\n      outerProps = _objectWithoutPropertiesLoose(_ref, [\"children\", \"transition\", \"popperConfig\"]);\n\n  var popperRef = useRef({});\n\n  var _usePopperMarginModif = usePopperMarginModifiers(),\n      ref = _usePopperMarginModif[0],\n      marginModifiers = _usePopperMarginModif[1];\n\n  transition = transition === true ? Fade : transition || null;\n  return /*#__PURE__*/React.createElement(BaseOverlay, _extends({}, outerProps, {\n    ref: ref,\n    popperConfig: _extends({}, popperConfig, {\n      modifiers: marginModifiers.concat(popperConfig.modifiers || [])\n    }),\n    transition: transition\n  }), function (_ref2) {\n    var overlayProps = _ref2.props,\n        arrowProps = _ref2.arrowProps,\n        show = _ref2.show,\n        state = _ref2.state,\n        scheduleUpdate = _ref2.scheduleUpdate,\n        placement = _ref2.placement,\n        outOfBoundaries = _ref2.outOfBoundaries,\n        props = _objectWithoutPropertiesLoose(_ref2, [\"props\", \"arrowProps\", \"show\", \"state\", \"scheduleUpdate\", \"placement\", \"outOfBoundaries\"]);\n\n    wrapRefs(overlayProps, arrowProps);\n    var popper = Object.assign(popperRef.current, {\n      state: state,\n      scheduleUpdate: scheduleUpdate,\n      placement: placement,\n      outOfBoundaries: outOfBoundaries\n    });\n    if (typeof overlay === 'function') return overlay(_extends({}, props, {}, overlayProps, {\n      placement: placement,\n      show: show,\n      popper: popper,\n      arrowProps: arrowProps\n    }));\n    return React.cloneElement(overlay, _extends({}, props, {}, overlayProps, {\n      placement: placement,\n      arrowProps: arrowProps,\n      popper: popper,\n      className: classNames(overlay.props.className, !transition && show && 'show'),\n      style: _extends({}, overlay.props.style, {}, overlayProps.style)\n    }));\n  });\n}\n\nOverlay.defaultProps = defaultProps;\nexport default Overlay;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport contains from 'dom-helpers/contains';\nimport React, { cloneElement, useCallback, useRef, useState } from 'react';\nimport useTimeout from '@restart/hooks/useTimeout';\nimport safeFindDOMNode from 'react-overlays/safeFindDOMNode';\nimport warning from 'warning';\nimport Overlay from './Overlay';\n\nvar RefHolder = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(RefHolder, _React$Component);\n\n  function RefHolder() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = RefHolder.prototype;\n\n  _proto.render = function render() {\n    return this.props.children;\n  };\n\n  return RefHolder;\n}(React.Component);\n\nfunction normalizeDelay(delay) {\n  return delay && typeof delay === 'object' ? delay : {\n    show: delay,\n    hide: delay\n  };\n} // Simple implementation of mouseEnter and mouseLeave.\n// React's built version is broken: https://github.com/facebook/react/issues/4251\n// for cases when the trigger is disabled and mouseOut/Over can cause flicker\n// moving from one child element to another.\n\n\nfunction handleMouseOverOut(handler, e, relatedNative) {\n  var target = e.currentTarget;\n  var related = e.relatedTarget || e.nativeEvent[relatedNative];\n\n  if ((!related || related !== target) && !contains(target, related)) {\n    handler(e);\n  }\n}\n\nvar defaultProps = {\n  defaultShow: false,\n  trigger: ['hover', 'focus']\n};\n\nfunction OverlayTrigger(_ref) {\n  var trigger = _ref.trigger,\n      overlay = _ref.overlay,\n      children = _ref.children,\n      _ref$popperConfig = _ref.popperConfig,\n      popperConfig = _ref$popperConfig === void 0 ? {} : _ref$popperConfig,\n      defaultShow = _ref.defaultShow,\n      propsDelay = _ref.delay,\n      placement = _ref.placement,\n      _ref$flip = _ref.flip,\n      flip = _ref$flip === void 0 ? placement && placement.indexOf('auto') !== -1 : _ref$flip,\n      props = _objectWithoutPropertiesLoose(_ref, [\"trigger\", \"overlay\", \"children\", \"popperConfig\", \"defaultShow\", \"delay\", \"placement\", \"flip\"]);\n\n  var triggerNodeRef = useRef(null);\n  var timeout = useTimeout();\n  var hoverStateRef = useRef();\n\n  var _useState = useState(!!defaultShow),\n      show = _useState[0],\n      setShow = _useState[1];\n\n  var delay = normalizeDelay(propsDelay);\n  var child = React.Children.only(children);\n  var _child$props = child.props,\n      onFocus = _child$props.onFocus,\n      onBlur = _child$props.onBlur,\n      onClick = _child$props.onClick;\n  var getTarget = useCallback(function () {\n    return safeFindDOMNode(triggerNodeRef.current);\n  }, []);\n  var handleShow = useCallback(function () {\n    timeout.clear();\n    hoverStateRef.current = 'show';\n\n    if (!delay.show) {\n      setShow(true);\n      return;\n    }\n\n    timeout.set(function () {\n      if (hoverStateRef.current === 'show') setShow(true);\n    }, delay.show);\n  }, [delay.show, timeout]);\n  var handleHide = useCallback(function () {\n    timeout.clear();\n    hoverStateRef.current = 'hide';\n\n    if (!delay.hide) {\n      setShow(false);\n      return;\n    }\n\n    timeout.set(function () {\n      if (hoverStateRef.current === 'hide') setShow(false);\n    }, delay.hide);\n  }, [delay.hide, timeout]);\n  var handleFocus = useCallback(function (e) {\n    handleShow(e);\n    if (onFocus) onFocus(e);\n  }, [handleShow, onFocus]);\n  var handleBlur = useCallback(function (e) {\n    handleHide(e);\n    if (onBlur) onBlur(e);\n  }, [handleHide, onBlur]);\n  var handleClick = useCallback(function (e) {\n    setShow(function (prevShow) {\n      return !prevShow;\n    });\n    if (onClick) onClick(e);\n  }, [onClick]);\n  var handleMouseOver = useCallback(function (e) {\n    handleMouseOverOut(handleShow, e, 'fromElement');\n  }, [handleShow]);\n  var handleMouseOut = useCallback(function (e) {\n    handleMouseOverOut(handleHide, e, 'toElement');\n  }, [handleHide]); // We add aria-describedby in the case where the overlay is a role=\"tooltip\"\n  // for other cases describedby isn't appropriate (e.g. a popover with inputs) so we don't add it.\n\n  var ariaModifier = {\n    name: 'ariaDescribedBy',\n    enabled: true,\n    phase: 'afterWrite',\n    effect: function effect(_ref2) {\n      var state = _ref2.state;\n      return function () {\n        state.elements.reference.removeAttribute('aria-describedby');\n      };\n    },\n    fn: function fn(_ref3) {\n      var state = _ref3.state;\n      var _state$elements = state.elements,\n          popper = _state$elements.popper,\n          reference = _state$elements.reference;\n      if (!show || !reference) return;\n      var role = popper.getAttribute('role') || '';\n\n      if (popper.id && role.toLowerCase() === 'tooltip') {\n        reference.setAttribute('aria-describedby', popper.id);\n      }\n    }\n  };\n  var triggers = trigger == null ? [] : [].concat(trigger);\n  var triggerProps = {};\n\n  if (triggers.indexOf('click') !== -1) {\n    triggerProps.onClick = handleClick;\n  }\n\n  if (triggers.indexOf('focus') !== -1) {\n    triggerProps.onFocus = handleFocus;\n    triggerProps.onBlur = handleBlur;\n  }\n\n  if (triggers.indexOf('hover') !== -1) {\n    process.env.NODE_ENV !== \"production\" ? warning(triggers.length > 1, '[react-bootstrap] Specifying only the `\"hover\"` trigger limits the visibility of the overlay to just mouse users. Consider also including the `\"focus\"` trigger so that touch and keyboard only users can see the overlay as well.') : void 0;\n    triggerProps.onMouseOver = handleMouseOver;\n    triggerProps.onMouseOut = handleMouseOut;\n  }\n\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(RefHolder, {\n    ref: triggerNodeRef\n  }, cloneElement(child, triggerProps)), /*#__PURE__*/React.createElement(Overlay, _extends({}, props, {\n    popperConfig: _extends({}, popperConfig, {\n      modifiers: [ariaModifier].concat(popperConfig.modifiers || [])\n    }),\n    show: show,\n    onHide: handleHide,\n    target: getTarget,\n    placement: placement,\n    flip: flip\n  }), overlay));\n}\n\nOverlayTrigger.defaultProps = defaultProps;\nexport default OverlayTrigger;","/* eslint-disable no-bitwise, no-cond-assign */\n// HTML DOM and SVG DOM may have different support levels,\n// so we need to check on context instead of a document root element.\nexport default function contains(context, node) {\n  if (context.contains) return context.contains(node);\n  if (context.compareDocumentPosition) return context === node || !!(context.compareDocumentPosition(node) & 16);\n}"],"sourceRoot":""}