{"version":3,"file":"popper.min.js","sources":["../../src/dom-utils/getBoundingClientRect.js","../../src/dom-utils/getWindow.js","../../src/dom-utils/getWindowScroll.js","../../src/dom-utils/instanceOf.js","../../src/dom-utils/getNodeName.js","../../src/dom-utils/getDocumentElement.js","../../src/dom-utils/getWindowScrollBarX.js","../../src/dom-utils/getCompositeRect.js","../../src/dom-utils/getNodeScroll.js","../../src/dom-utils/getHTMLElementScroll.js","../../src/dom-utils/getLayoutRect.js","../../src/dom-utils/getParentNode.js","../../src/dom-utils/getComputedStyle.js","../../src/dom-utils/listScrollParents.js","../../src/dom-utils/getScrollParent.js","../../src/dom-utils/getOffsetParent.js","../../src/dom-utils/isTableElement.js","../../src/utils/orderModifiers.js","../../src/utils/debounce.js","../../src/utils/getBasePlacement.js","../../src/index.js","../../src/utils/getMainAxisFromPlacement.js","../../src/utils/computeOffsets.js","../../src/utils/getVariation.js","../../src/enums.js","../../src/modifiers/computeStyles.js","../../src/utils/getOppositePlacement.js","../../src/utils/getOppositeVariationPlacement.js","../../src/dom-utils/contains.js","../../src/utils/rectToClientRect.js","../../src/dom-utils/getClippingRect.js","../../src/dom-utils/getViewportRect.js","../../src/dom-utils/getDocumentRect.js","../../src/dom-utils/getDecorations.js","../../src/dom-utils/getBorders.js","../../src/utils/mergePaddingObject.js","../../src/utils/getFreshSideObject.js","../../src/utils/expandToHashMap.js","../../src/utils/detectOverflow.js","../../src/modifiers/hide.js","../../src/modifiers/eventListeners.js","../../src/popper.js","../../src/modifiers/popperOffsets.js","../../src/modifiers/applyStyles.js","../../src/modifiers/offset.js","../../src/modifiers/flip.js","../../src/utils/uniqueBy.js","../../src/utils/computeAutoPlacement.js","../../src/modifiers/preventOverflow.js","../../src/utils/getAltAxis.js","../../src/utils/within.js","../../src/modifiers/arrow.js"],"sourcesContent":["// @flow\nimport type { ClientRectObject, VirtualElement } from '../types';\n\nexport default function getBoundingClientRect(\n  element: Element | VirtualElement\n): ClientRectObject {\n  const rect = element.getBoundingClientRect();\n\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}\n","// @flow\n/*:: import type { Window } from '../types'; */\n/*:: declare function getWindow(node: Node | Window): Window; */\n\nexport default function getWindow(node) {\n  if (node.toString() !== '[object Window]') {\n    const ownerDocument = node.ownerDocument;\n    return ownerDocument ? ownerDocument.defaultView : window;\n  }\n\n  return node;\n}\n","// @flow\nimport getWindow from './getWindow';\nimport type { Window } from '../types';\n\nexport default function getWindowScroll(node: Node | Window) {\n  const win = getWindow(node);\n  const scrollLeft = win.pageXOffset;\n  const scrollTop = win.pageYOffset;\n\n  return {\n    scrollLeft,\n    scrollTop,\n  };\n}\n","// @flow\nimport getWindow from './getWindow';\n\n/*:: declare function isElement(node: mixed): boolean %checks(node instanceof\n  Element); */\n\nfunction isElement(node) {\n  const OwnElement = getWindow(node).Element;\n  return node instanceof OwnElement;\n}\n\n/*:: declare function isHTMLElement(node: mixed): boolean %checks(node instanceof\n  HTMLElement); */\n\nfunction isHTMLElement(node) {\n  const OwnElement = getWindow(node).HTMLElement;\n  return node instanceof OwnElement;\n}\n\nexport { isElement, isHTMLElement };\n","// @flow\nimport type { Window } from '../types';\n\nexport default function getNodeName(element: ?Node | Window): ?string {\n  return element ? (element.nodeName || '').toLowerCase() : null;\n}\n","// @flow\nimport { isElement } from './instanceOf';\nimport type { Window } from '../types';\n\nexport default function getDocumentElement(\n  element: Element | Window\n): HTMLElement {\n  // $FlowFixMe: assume body is always available\n  return (isElement(element) ? element.ownerDocument : element.document)\n    .documentElement;\n}\n","// @flow\nimport getBoundingClientRect from './getBoundingClientRect';\nimport getDocumentElement from './getDocumentElement';\nimport getWindowScroll from './getWindowScroll';\n\nexport default function getWindowScrollBarX(element: Element): number {\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 (\n    getBoundingClientRect(getDocumentElement(element)).left +\n    getWindowScroll(element).scrollLeft\n  );\n}\n","// @flow\nimport type { Rect, VirtualElement, Window } from '../types';\nimport getBoundingClientRect from './getBoundingClientRect';\nimport getNodeScroll from './getNodeScroll';\nimport getNodeName from './getNodeName';\nimport { isHTMLElement } from './instanceOf';\nimport getWindowScrollBarX from './getWindowScrollBarX';\nimport getDocumentElement from './getDocumentElement';\n\n// Returns the composite rect of an element relative to its offsetParent.\n// Composite means it takes into account transforms as well as layout.\nexport default function getCompositeRect(\n  elementOrVirtualElement: Element | VirtualElement,\n  offsetParent: Element | Window,\n  isFixed: boolean = false\n): Rect {\n  let documentElement;\n  const rect = getBoundingClientRect(elementOrVirtualElement);\n\n  let scroll = { scrollLeft: 0, scrollTop: 0 };\n  let offsets = { x: 0, y: 0 };\n\n  if (!isFixed) {\n    if (getNodeName(offsetParent) !== 'body') {\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 = getDocumentElement(offsetParent))) {\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}\n","// @flow\nimport getWindowScroll from './getWindowScroll';\nimport getWindow from './getWindow';\nimport { isHTMLElement } from './instanceOf';\nimport getHTMLElementScroll from './getHTMLElementScroll';\nimport type { Window } from '../types';\n\nexport default function getNodeScroll(node: Node | Window) {\n  if (node === getWindow(node) || !isHTMLElement(node)) {\n    return getWindowScroll(node);\n  } else {\n    return getHTMLElementScroll(node);\n  }\n}\n","// @flow\n\nexport default function getHTMLElementScroll(element: HTMLElement) {\n  return {\n    scrollLeft: element.scrollLeft,\n    scrollTop: element.scrollTop,\n  };\n}\n","// @flow\nimport type { Rect } from '../types';\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: HTMLElement): Rect {\n  return {\n    x: element.offsetLeft,\n    y: element.offsetTop,\n    width: element.offsetWidth,\n    height: element.offsetHeight,\n  };\n}\n","// @flow\nimport getNodeName from './getNodeName';\n\nexport default function getParentNode(element: Node | ShadowRoot): Node {\n  if (getNodeName(element) === 'html') {\n    return element;\n  }\n\n  return (\n    element.parentNode || // DOM Element detected\n    // $FlowFixMe: need a better way to handle this...\n    element.host || // ShadowRoot detected\n    document.ownerDocument || // Fallback to ownerDocument if available\n    document.documentElement // Or to documentElement if everything else fails\n  );\n}\n","// @flow\nimport getWindow from './getWindow';\n\nexport default function getComputedStyle(\n  element: Element\n): CSSStyleDeclaration {\n  return getWindow(element).getComputedStyle(element);\n}\n","// @flow\nimport getScrollParent from './getScrollParent';\nimport getParentNode from './getParentNode';\nimport getNodeName from './getNodeName';\nimport getWindow from './getWindow';\nimport type { Window } from '../types';\n\nexport default function listScrollParents(\n  element: Node,\n  list: Array<Element | Window> = []\n): Array<Element | Window> {\n  const scrollParent = getScrollParent(element);\n  const isBody = getNodeName(scrollParent) === 'body';\n  const target = isBody ? getWindow(scrollParent) : scrollParent;\n  const updatedList = list.concat(target);\n\n  return isBody\n    ? updatedList\n    : // $FlowFixMe: isBody tells us target will be an HTMLElement here\n      updatedList.concat(listScrollParents(getParentNode(target)));\n}\n","// @flow\nimport getParentNode from './getParentNode';\nimport getComputedStyle from './getComputedStyle';\nimport getNodeName from './getNodeName';\nimport { isHTMLElement } from './instanceOf';\n\nexport default function getScrollParent(node: Node): HTMLElement {\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)) {\n    // Firefox wants us to check `-x` and `-y` variations as well\n    const { overflow, overflowX, overflowY } = getComputedStyle(node);\n\n    if (/auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX)) {\n      return node;\n    }\n  }\n\n  return getScrollParent(getParentNode(node));\n}\n","// @flow\nimport getWindow from './getWindow';\nimport getNodeName from './getNodeName';\nimport getComputedStyle from './getComputedStyle';\nimport { isHTMLElement } from './instanceOf';\nimport isTableElement from './isTableElement';\n\n// https://stackoverflow.com/a/9851769/2059996\nconst isFirefox = () => typeof window.InstallTrigger !== 'undefined';\n\nfunction getTrueOffsetParent(element: Element): ?Element {\n  let offsetParent;\n\n  if (\n    !isHTMLElement(element) ||\n    !(offsetParent = element.offsetParent) ||\n    // https://github.com/popperjs/popper.js/issues/837\n    (isFirefox() && getComputedStyle(offsetParent).position === 'fixed')\n  ) {\n    return null;\n  }\n\n  return offsetParent;\n}\n\nexport default function getOffsetParent(element: Element) {\n  const window = getWindow(element);\n\n  let offsetParent = getTrueOffsetParent(element);\n\n  // Find the nearest non-table offsetParent\n  while (offsetParent && isTableElement(offsetParent)) {\n    offsetParent = getTrueOffsetParent(offsetParent);\n  }\n\n  if (\n    offsetParent &&\n    getNodeName(offsetParent) === 'body' &&\n    getComputedStyle(offsetParent).position === 'static'\n  ) {\n    return window;\n  }\n\n  return offsetParent || window;\n}\n","// @flow\nimport getNodeName from './getNodeName';\n\nexport default function isTableElement(element: Element): boolean {\n  return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;\n}\n","// @flow\nimport type { Modifier } from '../types';\nimport { modifierPhases } from '../enums';\n\n// source: https://stackoverflow.com/questions/49875255\nfunction order(modifiers) {\n  const map = new Map();\n  const visited = new Set();\n  const result = [];\n\n  modifiers.forEach(modifier => {\n    map.set(modifier.name, modifier);\n  });\n\n  // On visiting object, check for its dependencies and visit them recursively\n  function sort(modifier: Modifier<any>) {\n    visited.add(modifier.name);\n\n    const requires = [\n      ...(modifier.requires || []),\n      ...(modifier.requiresIfExists || []),\n    ];\n\n    requires.forEach(dep => {\n      if (!visited.has(dep)) {\n        const depModifier = map.get(dep);\n\n        if (depModifier) {\n          sort(depModifier);\n        }\n      }\n    });\n\n    result.push(modifier);\n  }\n\n  modifiers.forEach(modifier => {\n    if (!visited.has(modifier.name)) {\n      // check for visited object\n      sort(modifier);\n    }\n  });\n\n  return result;\n}\n\nexport default function orderModifiers(\n  modifiers: Array<Modifier<any>>\n): Array<Modifier<any>> {\n  // order based on dependencies\n  const orderedModifiers = order(modifiers);\n\n  // order based on phase\n  return modifierPhases.reduce((acc, phase) => {\n    return acc.concat(\n      orderedModifiers.filter(modifier => modifier.phase === phase)\n    );\n  }, []);\n}\n","// @flow\n\nexport default function debounce<T>(fn: Function): () => Promise<T> {\n  let pending;\n  return () => {\n    if (!pending) {\n      pending = new Promise<T>(resolve => {\n        Promise.resolve().then(() => {\n          pending = undefined;\n          resolve(fn());\n        });\n      });\n    }\n\n    return pending;\n  };\n}\n","// @flow\nimport { type BasePlacement, type Placement, auto } from '../enums';\n\nexport default function getBasePlacement(\n  placement: Placement | typeof auto\n): BasePlacement {\n  return (placement.split('-')[0]: any);\n}\n","// @flow\nimport type {\n  State,\n  Options,\n  Modifier,\n  Instance,\n  VirtualElement,\n} from './types';\nimport getCompositeRect from './dom-utils/getCompositeRect';\nimport getLayoutRect from './dom-utils/getLayoutRect';\nimport listScrollParents from './dom-utils/listScrollParents';\nimport getOffsetParent from './dom-utils/getOffsetParent';\nimport getComputedStyle from './dom-utils/getComputedStyle';\nimport orderModifiers from './utils/orderModifiers';\nimport debounce from './utils/debounce';\nimport validateModifiers from './utils/validateModifiers';\nimport uniqueBy from './utils/uniqueBy';\nimport getBasePlacement from './utils/getBasePlacement';\nimport { isElement } from './dom-utils/instanceOf';\nimport { auto } from './enums';\n\nexport * from './types';\nexport * from './enums';\n\nconst INVALID_ELEMENT_ERROR =\n  'Popper: Invalid reference or popper argument provided to Popper, they must be either a valid DOM element, virtual element, or a jQuery-wrapped DOM element.';\nconst INFINITE_LOOP_ERROR =\n  'Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.';\n\nconst DEFAULT_OPTIONS: Options = {\n  placement: 'bottom',\n  modifiers: [],\n  strategy: 'absolute',\n};\n\ntype PopperGeneratorArgs = {\n  defaultModifiers?: Array<Modifier<any>>,\n  defaultOptions?: $Shape<Options>,\n};\n\nfunction areValidElements(...args: Array<any>): boolean {\n  return !args.some(\n    element => !(element && typeof element.getBoundingClientRect === 'function')\n  );\n}\n\nexport function popperGenerator(generatorOptions: PopperGeneratorArgs = {}) {\n  const {\n    defaultModifiers = [],\n    defaultOptions = DEFAULT_OPTIONS,\n  } = generatorOptions;\n\n  return function createPopper(\n    reference: Element | VirtualElement,\n    popper: HTMLElement,\n    options: $Shape<Options> = defaultOptions\n  ): Instance {\n    let state: $Shape<State> = {\n      placement: 'bottom',\n      orderedModifiers: [],\n      options: { ...DEFAULT_OPTIONS, ...defaultOptions },\n      modifiersData: {},\n      elements: {\n        reference,\n        popper,\n      },\n      attributes: {},\n      styles: {},\n    };\n\n    let effectCleanupFns: Array<() => void> = [];\n    let isDestroyed = false;\n\n    const instance = {\n      state,\n      setOptions(options) {\n        cleanupModifierEffects();\n\n        state.options = {\n          ...defaultOptions,\n          ...state.options,\n          ...options,\n        };\n\n        state.scrollParents = {\n          reference: isElement(reference) ? listScrollParents(reference) : [],\n          popper: listScrollParents(popper),\n        };\n\n        // Orders the modifiers based on their dependencies and `phase`\n        // properties\n        const orderedModifiers = orderModifiers([\n          ...state.options.modifiers.filter(\n            modifier =>\n              !defaultModifiers.find(({ name }) => name === modifier.name)\n          ),\n          ...defaultModifiers.map(defaultModifier => ({\n            ...defaultModifier,\n            ...state.options.modifiers.find(\n              ({ name }) => name === defaultModifier.name\n            ),\n          })),\n        ]);\n\n        // Validate the provided modifiers so that the consumer will get warned\n        // if one of the modifiers is invalid for any reason\n        if (__DEV__) {\n          const modifiers = uniqueBy(\n            [...orderedModifiers, ...state.options.modifiers],\n            ({ name }) => name\n          );\n\n          validateModifiers(modifiers);\n\n          if (getBasePlacement(state.options.placement) === auto) {\n            const flipModifier = orderedModifiers.find(\n              ({ name }) => name === 'flip'\n            );\n\n            if (!flipModifier) {\n              console.error(\n                [\n                  'Popper: \"auto\" placements require the \"flip\" modifier be',\n                  'present and enabled to work.',\n                ].join(' ')\n              );\n            }\n          }\n\n          const {\n            marginTop,\n            marginRight,\n            marginBottom,\n            marginLeft,\n          } = getComputedStyle(popper);\n\n          // 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          if (\n            [marginTop, marginRight, marginBottom, marginLeft].some(margin =>\n              parseFloat(margin)\n            )\n          ) {\n            console.warn(\n              [\n                'Popper: CSS \"margin\" styles cannot be used to apply padding',\n                'between the popper and its reference element or boundary.',\n                'To replicate margin, use the `offset` modifier, as well as',\n                'the `padding` option in the `preventOverflow` and `flip`',\n                'modifiers.',\n              ].join(' ')\n            );\n          }\n        }\n\n        // Strip out disabled modifiers\n        state.orderedModifiers = orderedModifiers.filter(m => m.enabled);\n\n        runModifierEffects();\n\n        return instance.update();\n      },\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() {\n        if (isDestroyed) {\n          return;\n        }\n\n        const { reference, popper } = state.elements;\n\n        // Don't proceed if `reference` or `popper` are not valid elements\n        // anymore\n        if (!areValidElements(reference, popper)) {\n          if (__DEV__) {\n            console.error(INVALID_ELEMENT_ERROR);\n          }\n          return;\n        }\n\n        // Store the reference and popper rects to be read by modifiers\n        state.rects = {\n          reference: getCompositeRect(\n            reference,\n            getOffsetParent(popper),\n            state.options.strategy === 'fixed'\n          ),\n          popper: getLayoutRect(popper),\n        };\n\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        state.reset = false;\n\n        state.placement = state.options.placement;\n\n        // 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        state.orderedModifiers.forEach(\n          modifier =>\n            (state.modifiersData[modifier.name] = {\n              ...modifier.data,\n            })\n        );\n\n        let __debug_loops__ = 0;\n        for (let index = 0; index < state.orderedModifiers.length; index++) {\n          if (__DEV__) {\n            __debug_loops__ += 1;\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          const { fn, options = {}, name } = state.orderedModifiers[index];\n\n          if (typeof fn === 'function') {\n            state = fn({ state, options, name, instance }) || state;\n          }\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<$Shape<State>>(\n        () =>\n          new Promise<$Shape<State>>(resolve => {\n            instance.forceUpdate();\n            resolve(state);\n          })\n      ),\n\n      destroy() {\n        cleanupModifierEffects();\n        isDestroyed = true;\n      },\n    };\n\n    if (!areValidElements(reference, popper)) {\n      if (__DEV__) {\n        console.error(INVALID_ELEMENT_ERROR);\n      }\n      return instance;\n    }\n\n    instance.setOptions(options).then(state => {\n      if (!isDestroyed && options.onFirstUpdate) {\n        options.onFirstUpdate(state);\n      }\n    });\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    function runModifierEffects() {\n      state.orderedModifiers.forEach(({ name, options = {}, effect }) => {\n        if (typeof effect === 'function') {\n          const cleanupFn = effect({ state, name, instance, options });\n          const noopFn = () => {};\n          effectCleanupFns.push(cleanupFn || noopFn);\n        }\n      });\n    }\n\n    function cleanupModifierEffects() {\n      effectCleanupFns.forEach(fn => fn());\n      effectCleanupFns = [];\n    }\n\n    return instance;\n  };\n}\n\nexport const createPopper = popperGenerator();\n","// @flow\nimport type { Placement } from '../enums';\n\nexport default function getMainAxisFromPlacement(\n  placement: Placement\n): 'x' | 'y' {\n  return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';\n}\n","// @flow\nimport getBasePlacement from './getBasePlacement';\nimport getVariation from './getVariation';\nimport getMainAxisFromPlacement from './getMainAxisFromPlacement';\nimport type {\n  Rect,\n  PositioningStrategy,\n  Offsets,\n  ClientRectObject,\n} from '../types';\nimport { top, right, bottom, left, start, end, type Placement } from '../enums';\n\nexport default function computeOffsets({\n  reference,\n  element,\n  placement,\n}: {\n  reference: Rect | ClientRectObject,\n  element: Rect | ClientRectObject,\n  strategy: PositioningStrategy,\n  placement?: Placement,\n}): Offsets {\n  const basePlacement = placement ? getBasePlacement(placement) : null;\n  const variation = placement ? getVariation(placement) : null;\n  const commonX = reference.x + reference.width / 2 - element.width / 2;\n  const commonY = reference.y + reference.height / 2 - element.height / 2;\n\n  let offsets;\n  switch (basePlacement) {\n    case top:\n      offsets = {\n        x: commonX,\n        y: reference.y - element.height,\n      };\n      break;\n    case bottom:\n      offsets = {\n        x: commonX,\n        y: reference.y + reference.height,\n      };\n      break;\n    case right:\n      offsets = {\n        x: reference.x + reference.width,\n        y: commonY,\n      };\n      break;\n    case left:\n      offsets = {\n        x: reference.x - element.width,\n        y: commonY,\n      };\n      break;\n    default:\n      offsets = {\n        x: reference.x,\n        y: reference.y,\n      };\n  }\n\n  const mainAxis = basePlacement\n    ? getMainAxisFromPlacement(basePlacement)\n    : null;\n\n  if (mainAxis != null) {\n    const len = mainAxis === 'y' ? 'height' : 'width';\n\n    switch (variation) {\n      case start:\n        offsets[mainAxis] =\n          Math.floor(offsets[mainAxis]) -\n          Math.floor(reference[len] / 2 - element[len] / 2);\n        break;\n      case end:\n        offsets[mainAxis] =\n          Math.floor(offsets[mainAxis]) +\n          Math.ceil(reference[len] / 2 - element[len] / 2);\n        break;\n      default:\n    }\n  }\n\n  return offsets;\n}\n","// @flow\nimport { type Variation, type Placement } from '../enums';\n\nexport default function getVariation(placement: Placement): ?Variation {\n  return (placement.split('-')[1]: any);\n}\n","// @flow\nexport const top: 'top' = 'top';\nexport const bottom: 'bottom' = 'bottom';\nexport const right: 'right' = 'right';\nexport const left: 'left' = 'left';\nexport const auto: 'auto' = 'auto';\nexport type BasePlacement =\n  | typeof top\n  | typeof bottom\n  | typeof right\n  | typeof left;\nexport const basePlacements: Array<BasePlacement> = [top, bottom, right, left];\n\nexport const start: 'start' = 'start';\nexport const end: 'end' = 'end';\nexport type Variation = typeof start | typeof end;\n\nexport const clippingParents: 'clippingParents' = 'clippingParents';\nexport const viewport: 'viewport' = 'viewport';\nexport type Boundary =\n  | HTMLElement\n  | Array<HTMLElement>\n  | typeof clippingParents;\nexport type RootBoundary = typeof viewport | 'document';\n\nexport const popper: 'popper' = 'popper';\nexport const reference: 'reference' = 'reference';\nexport type Context = typeof popper | typeof reference;\n\nexport type VariationPlacement =\n  | 'top-start'\n  | 'top-end'\n  | 'bottom-start'\n  | 'bottom-end'\n  | 'right-start'\n  | 'right-end'\n  | 'left-start'\n  | 'left-end';\nexport type AutoPlacement = 'auto' | 'auto-start' | 'auto-end';\nexport type ComputedPlacement = VariationPlacement | BasePlacement;\nexport type Placement = AutoPlacement | BasePlacement | VariationPlacement;\n\nexport const variationPlacements: Array<VariationPlacement> = basePlacements.reduce(\n  (acc: Array<VariationPlacement>, placement: BasePlacement) =>\n    acc.concat([(`${placement}-${start}`: any), (`${placement}-${end}`: any)]),\n  []\n);\nexport const placements: Array<Placement> = [...basePlacements, auto].reduce(\n  (\n    acc: Array<Placement>,\n    placement: BasePlacement | typeof auto\n  ): Array<Placement> =>\n    acc.concat([\n      placement,\n      (`${placement}-${start}`: any),\n      (`${placement}-${end}`: any),\n    ]),\n  []\n);\n\n// modifiers that need to read the DOM\nexport const beforeRead: 'beforeRead' = 'beforeRead';\nexport const read: 'read' = 'read';\nexport const afterRead: 'afterRead' = 'afterRead';\n// pure-logic modifiers\nexport const beforeMain: 'beforeMain' = 'beforeMain';\nexport const main: 'main' = 'main';\nexport const afterMain: 'afterMain' = 'afterMain';\n// modifier with the purpose to write to the DOM (or write into a framework state)\nexport const beforeWrite: 'beforeWrite' = 'beforeWrite';\nexport const write: 'write' = 'write';\nexport const afterWrite: 'afterWrite' = 'afterWrite';\nexport const modifierPhases: Array<ModifierPhases> = [\n  beforeRead,\n  read,\n  afterRead,\n  beforeMain,\n  main,\n  afterMain,\n  beforeWrite,\n  write,\n  afterWrite,\n];\n\nexport type ModifierPhases =\n  | typeof beforeRead\n  | typeof read\n  | typeof afterRead\n  | typeof beforeMain\n  | typeof main\n  | typeof afterMain\n  | typeof beforeWrite\n  | typeof write\n  | typeof afterWrite;\n","// @flow\nimport type {\n  PositioningStrategy,\n  Offsets,\n  Modifier,\n  ModifierArguments,\n  Rect,\n  Window,\n} from '../types';\nimport { type BasePlacement, top, left, right, bottom } from '../enums';\nimport getOffsetParent from '../dom-utils/getOffsetParent';\nimport getWindow from '../dom-utils/getWindow';\nimport getDocumentElement from '../dom-utils/getDocumentElement';\nimport getComputedStyle from '../dom-utils/getComputedStyle';\nimport getBasePlacement from '../utils/getBasePlacement';\n\ntype Options = {\n  gpuAcceleration: boolean,\n  adaptive: boolean,\n};\n\nconst unsetSides = {\n  top: 'auto',\n  right: 'auto',\n  bottom: 'auto',\n  left: 'auto',\n};\n\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.\nfunction roundOffsets({ x, y }): Offsets {\n  const dpr = (window: Window).devicePixelRatio || 1;\n\n  return {\n    x: Math.round(x * dpr) / dpr || 0,\n    y: Math.round(y * dpr) / dpr || 0,\n  };\n}\n\nexport function mapToStyles({\n  popper,\n  popperRect,\n  placement,\n  offsets,\n  position,\n  gpuAcceleration,\n  adaptive,\n}: {\n  popper: HTMLElement,\n  popperRect: Rect,\n  placement: BasePlacement,\n  offsets: Offsets,\n  position: PositioningStrategy,\n  gpuAcceleration: boolean,\n  adaptive: boolean,\n}) {\n  let { x, y } = roundOffsets(offsets);\n\n  const hasX = offsets.hasOwnProperty('x');\n  const hasY = offsets.hasOwnProperty('y');\n\n  let sideX: string = left;\n  let sideY: string = top;\n\n  if (adaptive) {\n    let offsetParent = getOffsetParent(popper);\n    if (offsetParent === getWindow(popper)) {\n      offsetParent = getDocumentElement(popper);\n    }\n\n    // $FlowFixMe: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it\n    /*:: offsetParent = (offsetParent: Element); */\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  const commonStyles = {\n    position,\n    ...(adaptive && unsetSides),\n  };\n\n  if (gpuAcceleration) {\n    return {\n      ...commonStyles,\n      [sideY]: hasY ? '0' : '',\n      [sideX]: hasX ? '0' : '',\n      // Layer acceleration can disable subpixel rendering which causes slightly\n      // blurry text on low PPI displays, so we want to use 2D transforms\n      // instead\n      transform:\n        ((window: Window).devicePixelRatio || 1) < 2\n          ? `translate(${x}px, ${y}px)`\n          : `translate3d(${x}px, ${y}px, 0)`,\n    };\n  }\n\n  return {\n    ...commonStyles,\n    [sideY]: hasY ? `${y}px` : '',\n    [sideX]: hasX ? `${x}px` : '',\n    transform: '',\n  };\n}\n\nfunction computeStyles({ state, options }: ModifierArguments<Options>) {\n  const { gpuAcceleration = true, adaptive = true } = options;\n\n  if (__DEV__) {\n    if (\n      adaptive &&\n      parseFloat(getComputedStyle(state.elements.popper).transitionDuration)\n    ) {\n      console.warn(\n        [\n          'Popper: The \"computeStyles\" modifier\\'s `adaptive` option must be',\n          'disabled if CSS transitions are applied to the popper element.',\n        ].join(' ')\n      );\n    }\n  }\n\n  const commonStyles = {\n    placement: getBasePlacement(state.placement),\n    popper: state.elements.popper,\n    popperRect: state.rects.popper,\n    gpuAcceleration,\n  };\n\n  // popper offsets are always available\n  state.styles.popper = {\n    ...state.styles.popper,\n    ...mapToStyles({\n      ...commonStyles,\n      offsets: state.modifiersData.popperOffsets,\n      position: state.options.strategy,\n      adaptive,\n    }),\n  };\n\n  // arrow offsets may not be available\n  if (state.modifiersData.arrow != null) {\n    state.styles.arrow = {\n      ...state.styles.arrow,\n      ...mapToStyles({\n        ...commonStyles,\n        offsets: state.modifiersData.arrow,\n        position: 'absolute',\n        adaptive: false,\n      }),\n    };\n  }\n\n  state.attributes.popper = {\n    ...state.attributes.popper,\n    'data-popper-placement': state.placement,\n  };\n}\n\nexport default ({\n  name: 'computeStyles',\n  enabled: true,\n  phase: 'beforeWrite',\n  fn: computeStyles,\n  data: {},\n}: Modifier<Options>);\n","// @flow\nimport type { Placement } from '../enums';\n\nconst hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };\n\nexport default function getOppositePlacement(placement: Placement): Placement {\n  return (placement.replace(\n    /left|right|bottom|top/g,\n    matched => hash[matched]\n  ): any);\n}\n","// @flow\nimport type { Placement } from '../enums';\n\nconst hash = { start: 'end', end: 'start' };\n\nexport default function getOppositeVariationPlacement(\n  placement: Placement\n): Placement {\n  return (placement.replace(/start|end/g, matched => hash[matched]): any);\n}\n","// @flow\nexport default function contains(parent: Element, child: Element) {\n  // $FlowFixMe: hasOwnProperty doesn't seem to work in tests\n  const isShadow = Boolean(child.getRootNode && child.getRootNode().host);\n\n  // First, attempt with faster native method\n  if (parent.contains(child)) {\n    return true;\n  }\n  // then fallback to custom implementation with Shadow DOM support\n  else if (isShadow) {\n    let next = child;\n    do {\n      if (next && parent.isSameNode(next)) {\n        return true;\n      }\n      // $FlowFixMe: need a better way to handle this...\n      next = next.parentNode || next.host;\n    } while (next);\n  }\n\n  // Give up, the result is false\n  return false;\n}\n","// @flow\nimport type { Rect, ClientRectObject } from '../types';\n\nexport default function rectToClientRect(rect: Rect): ClientRectObject {\n  return {\n    ...rect,\n    left: rect.x,\n    top: rect.y,\n    right: rect.x + rect.width,\n    bottom: rect.y + rect.height,\n  };\n}\n","// @flow\nimport type { ClientRectObject } from '../types';\nimport type { Boundary, RootBoundary } from '../enums';\nimport { viewport } from '../enums';\nimport getViewportRect from './getViewportRect';\nimport getDocumentRect from './getDocumentRect';\nimport listScrollParents from './listScrollParents';\nimport getOffsetParent from './getOffsetParent';\nimport getDocumentElement from './getDocumentElement';\nimport getComputedStyle from './getComputedStyle';\nimport { isElement, isHTMLElement } from './instanceOf';\nimport getBoundingClientRect from './getBoundingClientRect';\nimport getDecorations from './getDecorations';\nimport contains from './contains';\nimport rectToClientRect from '../utils/rectToClientRect';\n\nfunction getClientRectFromMixedType(\n  element: Element,\n  clippingParent: Element | RootBoundary\n): ClientRectObject {\n  return clippingParent === viewport\n    ? rectToClientRect(getViewportRect(element))\n    : isHTMLElement(clippingParent)\n    ? getBoundingClientRect(clippingParent)\n    : rectToClientRect(getDocumentRect(getDocumentElement(element)));\n}\n\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`\nfunction getClippingParents(element: Element): Array<Element> {\n  const clippingParents = listScrollParents(element);\n  const canEscapeClipping =\n    ['absolute', 'fixed'].indexOf(getComputedStyle(element).position) >= 0;\n  const clipperElement =\n    canEscapeClipping && isHTMLElement(element)\n      ? getOffsetParent(element)\n      : element;\n\n  if (!isElement(clipperElement)) {\n    return [];\n  }\n\n  // $FlowFixMe: https://github.com/facebook/flow/issues/1414\n  return clippingParents.filter(\n    clippingParent =>\n      isElement(clippingParent) && contains(clippingParent, clipperElement)\n  );\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping parents\nexport default function getClippingRect(\n  element: Element,\n  boundary: Boundary,\n  rootBoundary: RootBoundary\n): ClientRectObject {\n  const mainClippingParents =\n    boundary === 'clippingParents'\n      ? getClippingParents(element)\n      : [].concat(boundary);\n  const clippingParents = [...mainClippingParents, rootBoundary];\n  const firstClippingParent = clippingParents[0];\n\n  const clippingRect = clippingParents.reduce((accRect, clippingParent) => {\n    const rect = getClientRectFromMixedType(element, clippingParent);\n    const decorations = getDecorations(\n      isHTMLElement(clippingParent)\n        ? clippingParent\n        : getDocumentElement(element)\n    );\n\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\n    return accRect;\n  }, getClientRectFromMixedType(element, firstClippingParent));\n\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\n  return clippingRect;\n}\n","// @flow\nimport getWindow from './getWindow';\n\nexport default function getViewportRect(element: Element) {\n  const win = getWindow(element);\n\n  return {\n    width: win.innerWidth,\n    height: win.innerHeight,\n    x: 0,\n    y: 0,\n  };\n}\n","// @flow\nimport type { Rect } from '../types';\nimport getCompositeRect from './getCompositeRect';\nimport getWindow from './getWindow';\nimport getDocumentElement from './getDocumentElement';\nimport getWindowScroll from './getWindowScroll';\n\nexport default function getDocumentRect(element: HTMLElement): Rect {\n  const win = getWindow(element);\n  const winScroll = getWindowScroll(element);\n  const documentRect = getCompositeRect(getDocumentElement(element), win);\n\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\n  return documentRect;\n}\n","// @flow\nimport type { SideObject } from '../types';\nimport getBorders from './getBorders';\nimport getNodeName from './getNodeName';\nimport getWindow from './getWindow';\nimport getWindowScrollBarX from './getWindowScrollBarX';\n\n// Borders + scrollbars\nexport default function getDecorations(element: HTMLElement): SideObject {\n  const win = getWindow(element);\n  const borders = getBorders(element);\n  const isHTML = getNodeName(element) === 'html';\n  const winScrollBarX = getWindowScrollBarX(element);\n\n  const x = element.clientWidth + borders.right;\n  let y = element.clientHeight + borders.bottom;\n\n  // 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  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:\n      // RTL scrollbar (scrolling containers only)\n      element.clientLeft > borders.left\n        ? borders.right\n        : // LTR scrollbar\n        isHTML\n        ? win.innerWidth - x - winScrollBarX\n        : element.offsetWidth - x,\n    bottom: isHTML ? win.innerHeight - y : element.offsetHeight - y,\n    left: isHTML ? winScrollBarX : element.clientLeft,\n  };\n}\n","// @flow\nimport type { SideObject } from '../types';\nimport getComputedStyle from './getComputedStyle';\nimport { isHTMLElement } from './instanceOf';\n\nfunction toNumber(cssValue: string): number {\n  return parseFloat(cssValue) || 0;\n}\n\nexport default function getBorders(element: Element): SideObject {\n  const computedStyle = isHTMLElement(element) ? getComputedStyle(element) : {};\n\n  return {\n    top: toNumber(computedStyle.borderTopWidth),\n    right: toNumber(computedStyle.borderRightWidth),\n    bottom: toNumber(computedStyle.borderBottomWidth),\n    left: toNumber(computedStyle.borderLeftWidth),\n  };\n}\n","// @flow\nimport type { SideObject } from '../types';\nimport getFreshSideObject from './getFreshSideObject';\n\nexport default function mergePaddingObject(\n  paddingObject: $Shape<SideObject>\n): SideObject {\n  return {\n    ...getFreshSideObject(),\n    ...paddingObject,\n  };\n}\n","// @flow\nimport type { SideObject } from '../types';\n\nexport default function getFreshSideObject(): SideObject {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n  };\n}\n","// @flow\n\nexport default function expandToHashMap<\n  T: number | string | boolean,\n  K: string\n>(value: T, keys: Array<K>): { [key: string]: T } {\n  return keys.reduce((hashMap, key) => {\n    hashMap[key] = value;\n    return hashMap;\n  }, {});\n}\n","// @flow\nimport type { State, SideObject, Padding } from '../types';\nimport type { Placement, Boundary, RootBoundary, Context } from '../enums';\nimport getBoundingClientRect from '../dom-utils/getBoundingClientRect';\nimport getClippingRect from '../dom-utils/getClippingRect';\nimport getDocumentElement from '../dom-utils/getDocumentElement';\nimport computeOffsets from './computeOffsets';\nimport rectToClientRect from './rectToClientRect';\nimport {\n  clippingParents,\n  reference,\n  popper,\n  bottom,\n  top,\n  right,\n  basePlacements,\n  viewport,\n} from '../enums';\nimport { isElement } from '../dom-utils/instanceOf';\nimport mergePaddingObject from './mergePaddingObject';\nimport expandToHashMap from './expandToHashMap';\n\ntype Options = {\n  placement: Placement,\n  boundary: Boundary,\n  rootBoundary: RootBoundary,\n  elementContext: Context,\n  altBoundary: boolean,\n  padding: Padding,\n};\n\nexport default function detectOverflow(\n  state: State,\n  options: $Shape<Options> = {}\n): SideObject {\n  const {\n    placement = state.placement,\n    boundary = clippingParents,\n    rootBoundary = viewport,\n    elementContext = popper,\n    altBoundary = false,\n    padding = 0,\n  } = options;\n\n  const paddingObject = mergePaddingObject(\n    typeof padding !== 'number'\n      ? padding\n      : expandToHashMap(padding, basePlacements)\n  );\n\n  const altContext = elementContext === popper ? reference : popper;\n\n  const referenceElement = state.elements.reference;\n  const popperRect = state.rects.popper;\n  const element = state.elements[altBoundary ? altContext : elementContext];\n\n  const clippingClientRect = getClippingRect(\n    isElement(element) ? element : getDocumentElement(state.elements.popper),\n    boundary,\n    rootBoundary\n  );\n  const referenceClientRect = getBoundingClientRect(referenceElement);\n\n  const popperOffsets = computeOffsets({\n    reference: referenceClientRect,\n    element: popperRect,\n    strategy: 'absolute',\n    placement,\n  });\n\n  const popperClientRect = rectToClientRect({\n    ...popperRect,\n    ...popperOffsets,\n  });\n\n  const elementClientRect =\n    elementContext === popper ? popperClientRect : referenceClientRect;\n\n  // positive = overflowing the clipping rect\n  // 0 or negative = within the clipping rect\n  const overflowOffsets = {\n    top: clippingClientRect.top - elementClientRect.top + paddingObject.top,\n    bottom:\n      elementClientRect.bottom -\n      clippingClientRect.bottom +\n      paddingObject.bottom,\n    left: clippingClientRect.left - elementClientRect.left + paddingObject.left,\n    right:\n      elementClientRect.right - clippingClientRect.right + paddingObject.right,\n  };\n\n  const offsetData = state.modifiersData.offset;\n\n  // Offsets can be applied only to the popper element\n  if (elementContext === popper && offsetData) {\n    const offset = offsetData[placement];\n\n    Object.keys(overflowOffsets).forEach(key => {\n      const multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;\n      const axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x';\n      overflowOffsets[key] += offset[axis] * multiply;\n    });\n  }\n\n  return overflowOffsets;\n}\n","// @flow\nimport type {\n  ModifierArguments,\n  Modifier,\n  Rect,\n  Options,\n  SideObject,\n  Offsets,\n} from '../types';\nimport { top, bottom, left, right } from '../enums';\nimport detectOverflow from '../utils/detectOverflow';\n\nfunction getSideOffsets(\n  overflow: SideObject,\n  rect: Rect,\n  preventedOffsets: Offsets = { x: 0, y: 0 }\n): SideObject {\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: SideObject): boolean {\n  return [top, right, bottom, left].some(side => overflow[side] >= 0);\n}\n\nfunction hide({ state, name }: ModifierArguments<Options>) {\n  const referenceRect = state.rects.reference;\n  const popperRect = state.rects.popper;\n  const preventedOffsets = state.modifiersData.preventOverflow;\n\n  const referenceOverflow = detectOverflow(state, {\n    elementContext: 'reference',\n  });\n  const popperAltOverflow = detectOverflow(state, {\n    altBoundary: true,\n  });\n\n  const referenceClippingOffsets = getSideOffsets(\n    referenceOverflow,\n    referenceRect\n  );\n  const popperEscapeOffsets = getSideOffsets(\n    popperAltOverflow,\n    popperRect,\n    preventedOffsets\n  );\n\n  const isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);\n  const hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);\n\n  state.modifiersData[name] = {\n    referenceClippingOffsets,\n    popperEscapeOffsets,\n    isReferenceHidden,\n    hasPopperEscaped,\n  };\n\n  state.attributes.popper = {\n    ...state.attributes.popper,\n    'data-popper-reference-hidden': isReferenceHidden,\n    'data-popper-escaped': hasPopperEscaped,\n  };\n}\n\nexport default ({\n  name: 'hide',\n  enabled: true,\n  phase: 'main',\n  requiresIfExists: ['preventOverflow'],\n  fn: hide,\n}: Modifier<Options>);\n","// @flow\nimport type { ModifierArguments, Modifier } from '../types';\nimport getWindow from '../dom-utils/getWindow';\n\ntype Options = {\n  scroll: boolean,\n  resize: boolean,\n};\n\nconst passive = { passive: true };\n\nfunction effect({ state, instance, options }: ModifierArguments<Options>) {\n  const { scroll = true, resize = true } = options;\n\n  const window = getWindow(state.elements.popper);\n  const scrollParents = [\n    ...state.scrollParents.reference,\n    ...state.scrollParents.popper,\n  ];\n\n  if (scroll) {\n    scrollParents.forEach(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 () => {\n    if (scroll) {\n      scrollParents.forEach(scrollParent => {\n        scrollParent.removeEventListener('scroll', instance.update, passive);\n      });\n    }\n\n    if (resize) {\n      window.removeEventListener('resize', instance.update, passive);\n    }\n  };\n}\n\nexport default ({\n  name: 'eventListeners',\n  enabled: true,\n  phase: 'write',\n  fn: () => {},\n  effect,\n  data: {},\n}: Modifier<Options>);\n","// @flow\nimport { popperGenerator } from './index';\nimport eventListeners from './modifiers/eventListeners';\nimport popperOffsets from './modifiers/popperOffsets';\nimport computeStyles from './modifiers/computeStyles';\nimport applyStyles from './modifiers/applyStyles';\nimport offset from './modifiers/offset';\nimport flip from './modifiers/flip';\nimport preventOverflow from './modifiers/preventOverflow';\nimport arrow from './modifiers/arrow';\nimport hide from './modifiers/hide';\n\nconst defaultModifiers = [\n  eventListeners,\n  popperOffsets,\n  computeStyles,\n  applyStyles,\n  offset,\n  flip,\n  preventOverflow,\n  arrow,\n  hide,\n];\n\nconst createPopper = popperGenerator({ defaultModifiers });\n\n// eslint-disable-next-line import/no-unused-modules\nexport { createPopper, popperGenerator, defaultModifiers };\n","// @flow\nimport type { ModifierArguments, Modifier } from '../types';\nimport computeOffsets from '../utils/computeOffsets';\n\nfunction popperOffsets({ state, name }: ModifierArguments<{||}>) {\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}\n\nexport default ({\n  name: 'popperOffsets',\n  enabled: true,\n  phase: 'read',\n  fn: popperOffsets,\n  data: {},\n}: Modifier<{||}>);\n","// @flow\nimport type { Modifier, ModifierArguments } from '../types';\nimport getNodeName from '../dom-utils/getNodeName';\nimport { isHTMLElement } from '../dom-utils/instanceOf';\n\n// 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({ state }: ModifierArguments<{||}>) {\n  Object.keys(state.elements).forEach(name => {\n    const style = state.styles[name] || {};\n\n    const attributes = state.attributes[name] || {};\n    const element = state.elements[name];\n\n    // arrow is optional + virtual elements\n    if (!isHTMLElement(element) || !getNodeName(element)) {\n      return;\n    }\n\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    Object.assign(element.style, style);\n\n    Object.keys(attributes).forEach(name => {\n      const value = attributes[name];\n      if (value === false) {\n        element.removeAttribute(name);\n      } else {\n        element.setAttribute(name, value === true ? '' : value);\n      }\n    });\n  });\n}\n\nfunction effect({ state }: ModifierArguments<{||}>) {\n  const initialStyles = {\n    position: 'absolute',\n    left: '0',\n    top: '0',\n    margin: '0',\n  };\n\n  Object.assign(state.elements.popper.style, initialStyles);\n\n  return () => {\n    Object.keys(state.elements).forEach(name => {\n      const element = state.elements[name];\n      const styleProperties = Object.keys(\n        state.styles.hasOwnProperty(name)\n          ? { ...state.styles[name] }\n          : initialStyles\n      );\n      const attributes = state.attributes[name] || {};\n\n      // Set all values to an empty string to unset them\n      const style = styleProperties.reduce(\n        (style, property) => ({\n          ...style,\n          [String(property)]: '',\n        }),\n        {}\n      );\n\n      // arrow is optional + virtual elements\n      if (!isHTMLElement(element) || !getNodeName(element)) {\n        return;\n      }\n\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      Object.assign(element.style, style);\n\n      Object.keys(attributes).forEach(attribute =>\n        element.removeAttribute(attribute)\n      );\n    });\n  };\n}\n\nexport default ({\n  name: 'applyStyles',\n  enabled: true,\n  phase: 'write',\n  fn: applyStyles,\n  effect,\n  requires: ['computeStyles'],\n}: Modifier<{||}>);\n","// @flow\nimport type { Placement } from '../enums';\nimport type { ModifierArguments, Modifier, Rect, Offsets } from '../types';\nimport getBasePlacement from '../utils/getBasePlacement';\nimport { top, left, right, placements } from '../enums';\n\ntype OffsetsFunction = ({\n  popper: Rect,\n  reference: Rect,\n  placement: Placement,\n}) => [?number, ?number];\n\ntype Offset = OffsetsFunction | [?number, ?number];\n\ntype Options = {\n  offset: Offset,\n};\n\nexport function distanceAndSkiddingToXY(\n  placement: Placement,\n  rects: { popper: Rect, reference: Rect },\n  offset: Offset\n): Offsets {\n  const basePlacement = getBasePlacement(placement);\n  const invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;\n\n  let [skidding, distance] =\n    typeof offset === 'function'\n      ? offset({\n          ...rects,\n          placement,\n        })\n      : offset;\n\n  skidding = skidding || 0;\n  distance = (distance || 0) * invertDistance;\n\n  return [left, right].indexOf(basePlacement) >= 0\n    ? { x: distance, y: skidding }\n    : { x: skidding, y: distance };\n}\n\nfunction offset({ state, options, name }: ModifierArguments<Options>) {\n  const { offset = [0, 0] } = options;\n\n  const data = placements.reduce((acc, placement) => {\n    acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);\n    return acc;\n  }, {});\n\n  const { x, y } = data[state.placement];\n\n  state.modifiersData.popperOffsets.x += x;\n  state.modifiersData.popperOffsets.y += y;\n\n  state.modifiersData[name] = data;\n}\n\nexport default ({\n  name: 'offset',\n  enabled: true,\n  phase: 'main',\n  requires: ['popperOffsets'],\n  fn: offset,\n}: Modifier<Options>);\n","// @flow\nimport type { Placement, Boundary, RootBoundary } from '../enums';\nimport type { ModifierArguments, Modifier, Padding } from '../types';\nimport getOppositePlacement from '../utils/getOppositePlacement';\nimport getBasePlacement from '../utils/getBasePlacement';\nimport getOppositeVariationPlacement from '../utils/getOppositeVariationPlacement';\nimport detectOverflow from '../utils/detectOverflow';\nimport computeAutoPlacement from '../utils/computeAutoPlacement';\nimport uniqueBy from '../utils/uniqueBy';\nimport { bottom, top, start, right, left, auto } from '../enums';\nimport getVariation from '../utils/getVariation';\n\ntype Options = {\n  fallbackPlacements: Array<Placement>,\n  padding: Padding,\n  boundary: Boundary,\n  rootBoundary: RootBoundary,\n  flipVariations: boolean,\n};\n\nfunction getExpandedFallbackPlacements(placement: Placement): Array<Placement> {\n  if (getBasePlacement(placement) === auto) {\n    return [];\n  }\n\n  const oppositePlacement = getOppositePlacement(placement);\n\n  return [\n    getOppositeVariationPlacement(placement),\n    oppositePlacement,\n    getOppositeVariationPlacement(oppositePlacement),\n  ];\n}\n\nfunction flip({ state, options, name }: ModifierArguments<Options>) {\n  if (state.modifiersData[name]._skip) {\n    return;\n  }\n\n  const {\n    fallbackPlacements: specifiedFallbackPlacements,\n    padding,\n    boundary,\n    rootBoundary,\n    flipVariations = true,\n  } = options;\n\n  const preferredPlacement = state.options.placement;\n  const basePlacement = getBasePlacement(preferredPlacement);\n  const isBasePlacement = basePlacement === preferredPlacement;\n\n  const fallbackPlacements =\n    specifiedFallbackPlacements ||\n    (isBasePlacement || !flipVariations\n      ? [getOppositePlacement(preferredPlacement)]\n      : getExpandedFallbackPlacements(preferredPlacement));\n\n  const placements = uniqueBy(\n    [preferredPlacement, ...fallbackPlacements].reduce((acc, placement) => {\n      return getBasePlacement(placement) === auto\n        ? acc.concat(\n            computeAutoPlacement(state, {\n              placement,\n              boundary,\n              rootBoundary,\n              padding,\n              flipVariations,\n            })\n          )\n        : acc.concat(placement);\n    }, []),\n    placement => placement\n  );\n\n  const referenceRect = state.rects.reference;\n  const popperRect = state.rects.popper;\n\n  const checksMap: Map<string, Array<boolean>> = new Map();\n  let makeFallbackChecks = true;\n  let firstFittingPlacement = placements[0];\n\n  for (let i = 0; i < placements.length; i++) {\n    const placement = placements[i];\n    const basePlacement = getBasePlacement(placement);\n    const isStartVariation = getVariation(placement) === start;\n    const isVertical = [top, bottom].indexOf(basePlacement) >= 0;\n    const len = isVertical ? 'width' : 'height';\n\n    const overflow = detectOverflow(state, {\n      placement,\n      boundary,\n      rootBoundary,\n      padding,\n    });\n\n    let mainVariationSide: any = isVertical\n      ? isStartVariation\n        ? right\n        : left\n      : isStartVariation\n      ? bottom\n      : top;\n\n    if (referenceRect[len] > popperRect[len]) {\n      mainVariationSide = getOppositePlacement(mainVariationSide);\n    }\n\n    const altVariationSide: any = getOppositePlacement(mainVariationSide);\n\n    const checks = [\n      overflow[basePlacement] <= 0,\n      overflow[mainVariationSide] <= 0,\n      overflow[altVariationSide] <= 0,\n    ];\n\n    if (checks.every(check => check)) {\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    const numberOfChecks = flipVariations ? 3 : 1;\n\n    for (let i = numberOfChecks; i > 0; i--) {\n      const fittingPlacement = placements.find(placement => {\n        const checks = checksMap.get(placement);\n        if (checks) {\n          return checks.slice(0, i).every(check => check);\n        }\n      });\n\n      if (fittingPlacement) {\n        firstFittingPlacement = fittingPlacement;\n        break;\n      }\n    }\n  }\n\n  if (state.placement !== firstFittingPlacement) {\n    state.modifiersData[name]._skip = true;\n    state.placement = firstFittingPlacement;\n    state.reset = true;\n  }\n}\n\nexport default ({\n  name: 'flip',\n  enabled: true,\n  phase: 'main',\n  fn: flip,\n  requiresIfExists: ['offset'],\n  data: { _skip: false },\n}: Modifier<Options>);\n","// @flow\n\nexport default function uniqueBy<T>(arr: Array<T>, fn: T => any): Array<T> {\n  const identifiers = new Set();\n\n  return arr.filter(item => {\n    const identifier = fn(item);\n\n    if (!identifiers.has(identifier)) {\n      identifiers.add(identifier);\n      return true;\n    }\n  });\n}\n","// @flow\nimport type { State, Padding } from '../types';\nimport type {\n  Placement,\n  BasePlacement,\n  VariationPlacement,\n  Boundary,\n  RootBoundary,\n  ComputedPlacement,\n} from '../enums';\nimport getVariation from './getVariation';\nimport { variationPlacements, basePlacements } from '../enums';\nimport detectOverflow from './detectOverflow';\nimport getBasePlacement from './getBasePlacement';\n\ntype Options = {\n  placement: Placement,\n  padding: Padding,\n  boundary: Boundary,\n  rootBoundary: RootBoundary,\n  flipVariations: boolean,\n};\n\ntype OverflowsMap = {\n  [BasePlacement | VariationPlacement]: number,\n};\n\nexport default function computeAutoPlacement(\n  state: $Shape<State>,\n  options: Options = {}\n): Array<ComputedPlacement> {\n  const {\n    placement,\n    boundary,\n    rootBoundary,\n    padding,\n    flipVariations,\n  } = options;\n\n  const variation = getVariation(placement);\n\n  const placements = variation\n    ? flipVariations\n      ? variationPlacements\n      : variationPlacements.filter(\n          placement => getVariation(placement) === variation\n        )\n    : basePlacements;\n\n  // $FlowFixMe: Flow seems to have problems with two array unions...\n  const overflows: OverflowsMap = placements.reduce((acc, placement) => {\n    acc[placement] = detectOverflow(state, {\n      placement,\n      boundary,\n      rootBoundary,\n      padding,\n    })[getBasePlacement(placement)];\n\n    return acc;\n  }, {});\n\n  return Object.keys(overflows).sort((a, b) => overflows[a] - overflows[b]);\n}\n","// @flow\nimport { top, left, right, bottom, start } from '../enums';\nimport type { Placement, Boundary, RootBoundary } from '../enums';\nimport type { Rect, ModifierArguments, Modifier, Padding } from '../types';\nimport getBasePlacement from '../utils/getBasePlacement';\nimport getMainAxisFromPlacement from '../utils/getMainAxisFromPlacement';\nimport getAltAxis from '../utils/getAltAxis';\nimport within from '../utils/within';\nimport getLayoutRect from '../dom-utils/getLayoutRect';\nimport detectOverflow from '../utils/detectOverflow';\nimport getVariation from '../utils/getVariation';\nimport getFreshSideObject from '../utils/getFreshSideObject';\n\ntype TetherOffset =\n  | (({\n      popper: Rect,\n      reference: Rect,\n      placement: Placement,\n    }) => number)\n  | number;\n\ntype Options = {\n  /* Prevents boundaries overflow on the main axis */\n  mainAxis: boolean,\n  /* Prevents boundaries overflow on the alternate axis */\n  altAxis: boolean,\n  /* The area to check the popper is overflowing in */\n  boundary: Boundary,\n  /* If the popper is not overflowing the main area, fallback to this one */\n  rootBoundary: RootBoundary,\n  /**\n   * Allows the popper to overflow from its boundaries to keep it near its\n   * reference element\n   */\n  tether: boolean,\n  /* Offsets when the `tether` option should activate */\n  tetherOffset: TetherOffset,\n  /* Sets a padding to the provided boundary */\n  padding: Padding,\n};\n\nfunction preventOverflow({ state, options, name }: ModifierArguments<Options>) {\n  const {\n    mainAxis: checkMainAxis = true,\n    altAxis: checkAltAxis = false,\n    boundary,\n    rootBoundary,\n    padding,\n    tether = true,\n    tetherOffset = 0,\n  } = options;\n\n  const overflow = detectOverflow(state, { boundary, rootBoundary, padding });\n  const basePlacement = getBasePlacement(state.placement);\n  const variation = getVariation(state.placement);\n  const isBasePlacement = !variation;\n  const mainAxis = getMainAxisFromPlacement(basePlacement);\n  const altAxis = getAltAxis(mainAxis);\n  const popperOffsets = state.modifiersData.popperOffsets;\n  const referenceRect = state.rects.reference;\n  const popperRect = state.rects.popper;\n  const tetherOffsetValue =\n    typeof tetherOffset === 'function'\n      ? tetherOffset({\n          ...state.rects,\n          placement: state.placement,\n        })\n      : tetherOffset;\n\n  const data = { x: 0, y: 0 };\n\n  if (checkMainAxis) {\n    const mainSide = mainAxis === 'y' ? top : left;\n    const altSide = mainAxis === 'y' ? bottom : right;\n    const len = mainAxis === 'y' ? 'height' : 'width';\n    const offset = popperOffsets[mainAxis];\n\n    const min = popperOffsets[mainAxis] + overflow[mainSide];\n    const max = popperOffsets[mainAxis] - overflow[altSide];\n\n    const additive = tether ? -popperRect[len] / 2 : 0;\n\n    const minLen = variation === start ? referenceRect[len] : popperRect[len];\n    const maxLen = variation === start ? -popperRect[len] : -referenceRect[len];\n\n    // We need to include the arrow in the calculation so the arrow doesn't go\n    // outside the reference bounds\n    const arrowElement = state.elements.arrow;\n    const arrowRect =\n      tether && arrowElement\n        ? getLayoutRect(arrowElement)\n        : { width: 0, height: 0 };\n    const arrowPaddingObject = state.modifiersData['arrow#persistent']\n      ? state.modifiersData['arrow#persistent'].padding\n      : getFreshSideObject();\n    const arrowPaddingMin = arrowPaddingObject[mainSide];\n    const arrowPaddingMax = arrowPaddingObject[altSide];\n\n    // 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    const arrowLen = within(\n      0,\n      Math.abs(referenceRect[len] - arrowRect[len]),\n      arrowRect[len]\n    );\n\n    const minOffset = isBasePlacement\n      ? referenceRect[len] / 2 -\n        additive -\n        arrowLen -\n        arrowPaddingMin -\n        tetherOffsetValue\n      : minLen - arrowLen - arrowPaddingMin - tetherOffsetValue;\n    const maxOffset = isBasePlacement\n      ? -referenceRect[len] / 2 +\n        additive +\n        arrowLen +\n        arrowPaddingMax +\n        tetherOffsetValue\n      : maxLen + arrowLen + arrowPaddingMax + tetherOffsetValue;\n\n    const offsetModifierValue = state.modifiersData.offset\n      ? state.modifiersData.offset[state.placement][mainAxis]\n      : 0;\n    const tetherMin =\n      state.modifiersData.popperOffsets[mainAxis] +\n      minOffset -\n      offsetModifierValue;\n    const tetherMax =\n      state.modifiersData.popperOffsets[mainAxis] +\n      maxOffset -\n      offsetModifierValue;\n\n    const preventedOffset = within(\n      tether ? Math.min(min, tetherMin) : min,\n      offset,\n      tether ? Math.max(max, tetherMax) : max\n    );\n\n    state.modifiersData.popperOffsets[mainAxis] = preventedOffset;\n    data[mainAxis] = preventedOffset - offset;\n  }\n\n  if (checkAltAxis) {\n    const mainSide = mainAxis === 'x' ? top : left;\n    const altSide = mainAxis === 'x' ? bottom : right;\n    const offset = popperOffsets[altAxis];\n\n    const min = offset + overflow[mainSide];\n    const max = offset - overflow[altSide];\n\n    const preventedOffset = within(min, offset, max);\n\n    state.modifiersData.popperOffsets[altAxis] = preventedOffset;\n    data[altAxis] = preventedOffset - offset;\n  }\n\n  state.modifiersData[name] = data;\n}\n\nexport default ({\n  name: 'preventOverflow',\n  enabled: true,\n  phase: 'main',\n  fn: preventOverflow,\n  requiresIfExists: ['offset'],\n}: Modifier<Options>);\n","// @flow\n\nexport default function getAltAxis(axis: 'x' | 'y'): 'x' | 'y' {\n  return axis === 'x' ? 'y' : 'x';\n}\n","// @flow\n\nexport default function within(\n  min: number,\n  value: number,\n  max: number\n): number {\n  return Math.max(min, Math.min(value, max));\n}\n","// @flow\nimport type { Modifier, ModifierArguments, Padding } from '../types';\nimport getBasePlacement from '../utils/getBasePlacement';\nimport getLayoutRect from '../dom-utils/getLayoutRect';\nimport contains from '../dom-utils/contains';\nimport getMainAxisFromPlacement from '../utils/getMainAxisFromPlacement';\nimport within from '../utils/within';\nimport mergePaddingObject from '../utils/mergePaddingObject';\nimport expandToHashMap from '../utils/expandToHashMap';\nimport { left, right, basePlacements, top, bottom } from '../enums';\n\ntype Options = {\n  element: HTMLElement | string,\n  padding: Padding,\n};\n\nfunction arrow({ state, name }: ModifierArguments<Options>) {\n  const arrowElement = state.elements.arrow;\n  const popperOffsets = state.modifiersData.popperOffsets;\n  const basePlacement = getBasePlacement(state.placement);\n  const axis = getMainAxisFromPlacement(basePlacement);\n  const isVertical = [left, right].indexOf(basePlacement) >= 0;\n  const len = isVertical ? 'height' : 'width';\n\n  if (!arrowElement) {\n    return;\n  }\n\n  const paddingObject = state.modifiersData[`${name}#persistent`].padding;\n  const arrowRect = getLayoutRect(arrowElement);\n  const minProp = axis === 'y' ? top : left;\n  const maxProp = axis === 'y' ? bottom : right;\n\n  const endDiff =\n    state.rects.reference[len] +\n    state.rects.reference[axis] -\n    popperOffsets[axis] -\n    state.rects.popper[len];\n  const startDiff = popperOffsets[axis] - state.rects.reference[axis];\n\n  const centerToReference = endDiff / 2 - startDiff / 2;\n\n  // Make sure the arrow doesn't overflow the popper if the center point is\n  // outside of the popper bounds\n  const center = within(\n    paddingObject[minProp],\n    state.rects.popper[len] / 2 - arrowRect[len] / 2 + centerToReference,\n    state.rects.popper[len] - arrowRect[len] - paddingObject[maxProp]\n  );\n\n  // Prevents breaking syntax highlighting...\n  const axisProp: string = axis;\n  state.modifiersData[name] = { [axisProp]: center };\n}\n\nfunction effect({ state, options, name }: ModifierArguments<Options>) {\n  let { element: arrowElement = '[data-popper-arrow]', padding = 0 } = options;\n\n  // CSS selector\n  if (typeof arrowElement === 'string') {\n    arrowElement = state.elements.popper.querySelector(arrowElement);\n\n    if (!arrowElement) {\n      return;\n    }\n  }\n\n  if (!contains(state.elements.popper, arrowElement)) {\n    if (__DEV__) {\n      console.error(\n        [\n          'Popper: \"arrow\" modifier\\'s `element` must be a child of the popper',\n          'element.',\n        ].join(' ')\n      );\n    }\n\n    return;\n  }\n\n  state.elements.arrow = arrowElement;\n  state.modifiersData[`${name}#persistent`] = {\n    padding: mergePaddingObject(\n      typeof padding !== 'number'\n        ? padding\n        : expandToHashMap(padding, basePlacements)\n    ),\n  };\n}\n\nexport default ({\n  name: 'arrow',\n  enabled: true,\n  phase: 'main',\n  fn: arrow,\n  effect,\n  requires: ['popperOffsets'],\n  requiresIfExists: ['preventOverflow'],\n}: Modifier<Options>);\n"],"names":["getBoundingClientRect","element","width","rect","height","top","right","bottom","left","x","y","getWindow","node","ownerDocument","window","getWindowScroll","scrollLeft","win","scrollTop","isElement","isHTMLElement","getNodeName","getDocumentElement","getWindowScrollBarX","getCompositeRect","elementOrVirtualElement","offsetParent","isFixed","scroll","offsets","documentElement","getLayoutRect","getParentNode","document","getComputedStyle","listScrollParents","list","scrollParent","getScrollParent","isBody","target","updatedList","getTrueOffsetParent","getOffsetParent","order","modifiers","map","Map","visited","Set","result","modifier","dep","depModifier","sort","debounce","fn","pending","Promise","resolve","undefined","getBasePlacement","placement","areValidElements","args","popperGenerator","generatorOptions","defaultModifiers","defaultOptions","DEFAULT_OPTIONS","reference","popper","options","effectCleanupFns","state","orderedModifiers","modifiersData","elements","attributes","styles","isDestroyed","instance","setOptions","cleanupModifierEffects","orderModifiers","acc","phase","defaultModifier","m","name","cleanupFn","effect","noopFn","forceUpdate","index","update","destroy","getMainAxisFromPlacement","computeOffsets","basePlacement","commonX","commonY","mainAxis","len","variation","start","Math","end","mapToStyles","popperRect","position","gpuAcceleration","adaptive","dpr","hasX","sideX","sideY","commonStyles","unsetSides","hasY","getOppositePlacement","matched","getOppositeVariationPlacement","contains","parent","child","isShadow","next","rectToClientRect","getClientRectFromMixedType","clippingParent","viewport","documentRect","winScroll","getClippingRect","boundary","rootBoundary","mainClippingParents","getClippingParents","clippingParents","clipperElement","accRect","computedStyle","parseFloat","winScrollBarX","borders","isHTML","decorations","clippingRect","mergePaddingObject","paddingObject","expandToHashMap","value","keys","hashMap","key","detectOverflow","altBoundary","padding","basePlacements","referenceElement","elementContext","strategy","popperOffsets","popperClientRect","referenceClientRect","overflowOffsets","clippingClientRect","elementClientRect","offsetData","offset","multiply","axis","overflow","preventedOffsets","isAnySideFullyClipped","side","variationPlacements","placements","auto","modifierPhases","passive","hash","eventListeners","enabled","resize","scrollParents","data","popperOffsets$1","computeStyles$1","computeStyles","applyStyles$1","applyStyles","style","Object","effect$1","initialStyles","margin","styleProperties","property","String","attribute","requires","offset$1","distanceAndSkiddingToXY","invertDistance","rects","distance","skidding","flip$1","flip","specifiedFallbackPlacements","flipVariations","preferredPlacement","getExpandedFallbackPlacements","oppositePlacement","uniqueBy","arr","identifiers","item","identifier","fallbackPlacements","computeAutoPlacement","overflows","a","b","checksMap","firstFittingPlacement","i","isStartVariation","isVertical","mainVariationSide","altVariationSide","check","checks","makeFallbackChecks","fittingPlacement","requiresIfExists","_skip","preventOverflow$1","preventOverflow","checkMainAxis","tetherOffset","isBasePlacement","referenceRect","tetherOffsetValue","mainSide","altSide","min","max","additive","tether","minLen","arrowElement","arrowPaddingObject","arrowRect","arrowLen","arrowPaddingMin","offsetModifierValue","arrowPaddingMax","maxLen","tetherMin","tetherMax","preventedOffset","checkAltAxis","altAxis","arrow$1","arrow","center","effect$2","hide$1","hide","referenceOverflow","popperAltOverflow","getSideOffsets","referenceClippingOffsets","popperEscapeOffsets","isReferenceHidden","hasPopperEscaped","createPopper"],"mappings":"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"}