{"version":3,"sources":["webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getWindow.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/instanceOf.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getNodeName.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getParentNode.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/isTableElement.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/enums.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/orderModifiers.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/debounce.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/mergeByName.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/index.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/modifiers/eventListeners.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/getBasePlacement.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/getVariation.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/computeOffsets.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/modifiers/popperOffsets.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/modifiers/computeStyles.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/modifiers/applyStyles.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/modifiers/offset.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/getOppositePlacement.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getBorders.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getDecorations.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/contains.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/rectToClientRect.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/dom-utils/getClippingRect.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/getFreshSideObject.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/mergePaddingObject.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/expandToHashMap.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/detectOverflow.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/modifiers/flip.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/getAltAxis.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/utils/within.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/modifiers/preventOverflow.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/modifiers/arrow.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/modifiers/hide.js","webpack:///./node_modules/v-calendar/node_modules/@popperjs/core/lib/popper.js"],"names":["getBoundingClientRect","element","rect","width","height","top","right","bottom","left","x","y","getWindow","node","toString","ownerDocument","defaultView","window","getWindowScroll","win","scrollLeft","pageXOffset","scrollTop","pageYOffset","isElement","OwnElement","Element","isHTMLElement","HTMLElement","getHTMLElementScroll","getNodeScroll","getNodeName","nodeName","toLowerCase","getDocumentElement","document","documentElement","getWindowScrollBarX","getComputedStyle","isScrollParent","_getComputedStyle","overflow","overflowX","overflowY","test","getCompositeRect","elementOrVirtualElement","offsetParent","isFixed","scroll","offsets","clientLeft","clientTop","getLayoutRect","offsetLeft","offsetTop","offsetWidth","offsetHeight","getParentNode","assignedSlot","parentNode","host","getScrollParent","indexOf","body","listScrollParents","list","scrollParent","isBody","target","concat","visualViewport","updatedList","isTableElement","getTrueOffsetParent","position","getOffsetParent","auto","basePlacements","start","end","viewport","variationPlacements","reduce","acc","placement","beforeRead","read","afterRead","beforeMain","main","afterMain","beforeWrite","write","afterWrite","modifierPhases","order","modifiers","map","Map","visited","Set","result","sort","modifier","add","name","requires","requiresIfExists","forEach","dep","has","depModifier","get","push","set","orderModifiers","orderedModifiers","phase","filter","debounce","fn","pending","Promise","resolve","then","undefined","mergeByName","merged","current","existing","Object","assign","options","data","keys","key","DEFAULT_OPTIONS","strategy","areValidElements","_len","arguments","length","args","Array","_key","some","popperGenerator","generatorOptions","_generatorOptions","_generatorOptions$def","defaultModifiers","_generatorOptions$def2","defaultOptions","reference","popper","state","modifiersData","elements","attributes","styles","effectCleanupFns","isDestroyed","instance","setOptions","cleanupModifierEffects","scrollParents","contextElement","m","enabled","runModifierEffects","update","forceUpdate","_state$elements","rects","reset","index","_state$orderedModifie","_state$orderedModifie2","_options","destroy","_ref3","_ref3$options","effect","cleanupFn","noopFn","onFirstUpdate","passive","_ref","_options$scroll","_options$resize","resize","addEventListener","removeEventListener","getBasePlacement","split","getVariation","getMainAxisFromPlacement","computeOffsets","basePlacement","variation","commonX","commonY","mainAxis","len","Math","floor","ceil","unsetSides","roundOffsets","dpr","devicePixelRatio","round","mapToStyles","_ref2","_Object$assign2","popperRect","gpuAcceleration","adaptive","_roundOffsets","hasX","hasOwnProperty","hasY","sideX","sideY","clientHeight","clientWidth","_Object$assign","commonStyles","transform","computeStyles","_options$gpuAccelerat","_options$adaptive","popperOffsets","arrow","applyStyles","style","value","removeAttribute","setAttribute","initialStyles","margin","styleProperties","property","attribute","distanceAndSkiddingToXY","offset","invertDistance","skidding","distance","_options$offset","_data$state$placement","hash","getOppositePlacement","replace","matched","getOppositeVariationPlacement","getViewportRect","innerWidth","innerHeight","navigator","platform","getDocumentRect","winScroll","documentRect","max","toNumber","cssValue","parseFloat","getBorders","computedStyle","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","getDecorations","borders","isHTML","winScrollBarX","contains","parent","child","isShadow","Boolean","getRootNode","next","isSameNode","rectToClientRect","getClientRectFromMixedType","clippingParent","getClippingParents","clippingParents","canEscapeClipping","clipperElement","getClippingRect","boundary","rootBoundary","mainClippingParents","firstClippingParent","clippingRect","accRect","decorations","min","getFreshSideObject","mergePaddingObject","paddingObject","expandToHashMap","hashMap","detectOverflow","_options$placement","_options$boundary","_options$rootBoundary","_options$elementConte","elementContext","_options$altBoundary","altBoundary","_options$padding","padding","altContext","referenceElement","clippingClientRect","referenceClientRect","popperClientRect","elementClientRect","overflowOffsets","offsetData","multiply","axis","computeAutoPlacement","flipVariations","_options$allowedAutoP","allowedAutoPlacements","placements","overflows","a","b","getExpandedFallbackPlacements","oppositePlacement","flip","_skip","_options$mainAxis","checkMainAxis","_options$altAxis","altAxis","checkAltAxis","specifiedFallbackPlacements","fallbackPlacements","_options$flipVariatio","preferredPlacement","isBasePlacement","referenceRect","checksMap","makeFallbackChecks","firstFittingPlacement","i","_basePlacement","isStartVariation","isVertical","mainVariationSide","altVariationSide","checks","every","check","numberOfChecks","_loop","_i","fittingPlacement","find","slice","_ret","getAltAxis","within","preventOverflow","_options$tether","tether","_options$tetherOffset","tetherOffset","tetherOffsetValue","mainSide","altSide","additive","minLen","maxLen","arrowElement","arrowRect","arrowPaddingObject","arrowPaddingMin","arrowPaddingMax","arrowLen","minOffset","maxOffset","arrowOffsetParent","clientOffset","offsetModifierValue","tetherMin","tetherMax","preventedOffset","_mainSide","_altSide","_offset","_min","_max","_preventedOffset","_state$modifiersData$","minProp","maxProp","endDiff","startDiff","clientSize","centerToReference","center","axisProp","centerOffset","_options$element","querySelector","getSideOffsets","preventedOffsets","isAnySideFullyClipped","side","hide","referenceOverflow","popperAltOverflow","referenceClippingOffsets","popperEscapeOffsets","isReferenceHidden","hasPopperEscaped","eventListeners"],"mappings":"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","file":"js/group-course-v2~group-homework~group-lesson~group-lessons~group-timetable~03694383.9c2bcbbd.js","sourcesContent":["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 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}","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 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 };","export default function getHTMLElementScroll(element) {\n  return {\n    scrollLeft: element.scrollLeft,\n    scrollTop: element.scrollTop\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 getNodeName(element) {\n  return element ? (element.nodeName || '').toLowerCase() : null;\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 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 getWindow from \"./getWindow.js\";\nexport default function getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\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}","// 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}","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 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 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 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 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 { 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}","export 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}","export 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 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 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 { auto } from \"../enums.js\";\nexport default function getBasePlacement(placement) {\n  return placement.split('-')[0];\n}","export default function getVariation(placement) {\n  return placement.split('-')[1];\n}","export default function getMainAxisFromPlacement(placement) {\n  return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';\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 computeOffsets from \"../utils/computeOffsets.js\";\n\nfunction popperOffsets(_ref) {\n  var state = _ref.state,\n      name = _ref.name;\n  // 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  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 { 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 getNodeName from \"../dom-utils/getNodeName.js\";\nimport { isHTMLElement } from \"../dom-utils/instanceOf.js\"; // This modifier takes the styles prepared by the `computeStyles` modifier\n// and applies them to the HTMLElements such as popper and arrow\n\nfunction applyStyles(_ref) {\n  var state = _ref.state;\n  Object.keys(state.elements).forEach(function (name) {\n    var style = state.styles[name] || {};\n    var attributes = state.attributes[name] || {};\n    var element = state.elements[name]; // arrow is optional + virtual elements\n\n    if (!isHTMLElement(element) || !getNodeName(element)) {\n      return;\n    } // Flow doesn't support to extend this property, but it's the most\n    // effective way to apply styles to an HTMLElement\n    // $FlowFixMe\n\n\n    Object.assign(element.style, style);\n    Object.keys(attributes).forEach(function (name) {\n      var value = attributes[name];\n\n      if (value === false) {\n        element.removeAttribute(name);\n      } else {\n        element.setAttribute(name, value === true ? '' : value);\n      }\n    });\n  });\n}\n\nfunction effect(_ref2) {\n  var state = _ref2.state;\n  var initialStyles = {\n    popper: {\n      position: state.options.strategy,\n      left: '0',\n      top: '0',\n      margin: '0'\n    },\n    arrow: {\n      position: 'absolute'\n    },\n    reference: {}\n  };\n  Object.assign(state.elements.popper.style, initialStyles.popper);\n\n  if (state.elements.arrow) {\n    Object.assign(state.elements.arrow.style, initialStyles.arrow);\n  }\n\n  return function () {\n    Object.keys(state.elements).forEach(function (name) {\n      var element = state.elements[name];\n      var attributes = state.attributes[name] || {};\n      var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them\n\n      var style = styleProperties.reduce(function (style, property) {\n        style[property] = '';\n        return style;\n      }, {}); // arrow is optional + virtual elements\n\n      if (!isHTMLElement(element) || !getNodeName(element)) {\n        return;\n      } // Flow doesn't support to extend this property, but it's the most\n      // effective way to apply styles to an HTMLElement\n      // $FlowFixMe\n\n\n      Object.assign(element.style, style);\n      Object.keys(attributes).forEach(function (attribute) {\n        element.removeAttribute(attribute);\n      });\n    });\n  };\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n  name: 'applyStyles',\n  enabled: true,\n  phase: 'write',\n  fn: applyStyles,\n  effect: effect,\n  requires: ['computeStyles']\n};","import 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};","var 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}","var 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}","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 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}","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}","export 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}","export default function getFreshSideObject() {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0\n  };\n}","import getFreshSideObject from \"./getFreshSideObject.js\";\nexport default function mergePaddingObject(paddingObject) {\n  return Object.assign({}, getFreshSideObject(), {}, paddingObject);\n}","export default function expandToHashMap(value, keys) {\n  return keys.reduce(function (hashMap, key) {\n    hashMap[key] = value;\n    return hashMap;\n  }, {});\n}","import 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 getVariation from \"./getVariation.js\";\nimport { variationPlacements, basePlacements, placements as allPlacements } from \"../enums.js\";\nimport detectOverflow from \"./detectOverflow.js\";\nimport getBasePlacement from \"./getBasePlacement.js\";\n\n/*:: type OverflowsMap = { [ComputedPlacement]: number }; */\n\n/*;; type OverflowsMap = { [key in ComputedPlacement]: number }; */\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 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};","export default function getAltAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}","export default function within(min, value, max) {\n  return Math.max(min, Math.min(value, max));\n}","import { 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};","import 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 { 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 { popperGenerator } from \"./index.js\";\nimport eventListeners from \"./modifiers/eventListeners.js\";\nimport popperOffsets from \"./modifiers/popperOffsets.js\";\nimport computeStyles from \"./modifiers/computeStyles.js\";\nimport applyStyles from \"./modifiers/applyStyles.js\";\nimport offset from \"./modifiers/offset.js\";\nimport flip from \"./modifiers/flip.js\";\nimport preventOverflow from \"./modifiers/preventOverflow.js\";\nimport arrow from \"./modifiers/arrow.js\";\nimport hide from \"./modifiers/hide.js\";\nimport detectOverflow from \"./utils/detectOverflow.js\";\nvar defaultModifiers = [eventListeners, popperOffsets, computeStyles, applyStyles, offset, flip, preventOverflow, arrow, hide];\nvar createPopper = /*#__PURE__*/popperGenerator({\n  defaultModifiers: defaultModifiers\n}); // eslint-disable-next-line import/no-unused-modules\n\nexport { createPopper, popperGenerator, defaultModifiers, detectOverflow };"],"sourceRoot":""}