{"version":3,"file":"4001.19124c0ddda94e42.js","mappings":"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","sources":["webpack:///../node_modules/classnames/index.js","webpack:///../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","webpack:///../node_modules/@floating-ui/core/dist/floating-ui.core.mjs","webpack:///../node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs","webpack:///../node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","webpack:///../node_modules/react-tooltip/dist/react-tooltip.min.mjs"],"sourcesContent":["/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = '';\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (arg) {\n\t\t\t\tclasses = appendClass(classes, parseValue(arg));\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction parseValue (arg) {\n\t\tif (typeof arg === 'string' || typeof arg === 'number') {\n\t\t\treturn arg;\n\t\t}\n\n\t\tif (typeof arg !== 'object') {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (Array.isArray(arg)) {\n\t\t\treturn classNames.apply(null, arg);\n\t\t}\n\n\t\tif (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n\t\t\treturn arg.toString();\n\t\t}\n\n\t\tvar classes = '';\n\n\t\tfor (var key in arg) {\n\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\tclasses = appendClass(classes, key);\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction appendClass (value, newClass) {\n\t\tif (!newClass) {\n\t\t\treturn value;\n\t\t}\n\t\n\t\tif (value) {\n\t\t\treturn value + ' ' + newClass;\n\t\t}\n\t\n\t\treturn value + newClass;\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","/**\n * Custom positioning reference element.\n * @see https://floating-ui.com/docs/virtual-elements\n */\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst alignments = ['start', 'end'];\nconst placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-\" + alignments[0], side + \"-\" + alignments[1]), []);\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  const {\n    x,\n    y,\n    width,\n    height\n  } = rect;\n  return {\n    width,\n    height,\n    top: y,\n    left: x,\n    right: x + width,\n    bottom: y + height,\n    x,\n    y\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n","import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    x,\n    y,\n    width: rects.floating.width,\n    height: rects.floating.height\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const initialSideAxis = getSideAxis(initialPlacement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';\n      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle.\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$filter2;\n                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {\n                  if (hasFallbackAxisSideDirection) {\n                    const currentSideAxis = getSideAxis(d.placement);\n                    return currentSideAxis === initialSideAxis ||\n                    // Create a bias to the `y` side axis due to horizontal\n                    // reading directions favoring greater width.\n                    currentSideAxis === 'y';\n                  }\n                  return true;\n                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n// For type backwards-compatibility, the `OffsetOptions` type was also\n// Derivable.\n\nasync function convertValueToCoords(state, options) {\n  const {\n    placement,\n    platform,\n    elements\n  } = state;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getSideAxis(placement) === 'y';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: 0,\n    crossAxis: 0,\n    alignmentAxis: null,\n    ...rawValue\n  };\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = function (options) {\n  if (options === void 0) {\n    options = 0;\n  }\n  return {\n    name: 'offset',\n    options,\n    async fn(state) {\n      var _middlewareData$offse, _middlewareData$arrow;\n      const {\n        x,\n        y,\n        placement,\n        middlewareData\n      } = state;\n      const diffCoords = await convertValueToCoords(state, options);\n\n      // If the placement is the same and the arrow caused an alignment offset\n      // then we don't need to change the positioning coordinates.\n      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: {\n          ...diffCoords,\n          placement\n        }\n      };\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'shift',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y,\n        placement\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const crossAxis = getSideAxis(getSide(placement));\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = clamp(min, mainAxisCoord, max);\n      }\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = clamp(min, crossAxisCoord, max);\n      }\n      const limitedCoords = limiter.fn({\n        ...state,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return {\n        ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y\n        }\n      };\n    }\n  };\n};\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    options,\n    fn(state) {\n      const {\n        x,\n        y,\n        placement,\n        rects,\n        middlewareData\n      } = state;\n      const {\n        offset = 0,\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const crossAxis = getSideAxis(placement);\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      const rawOffset = evaluate(offset, state);\n      const computedOffset = typeof rawOffset === 'number' ? {\n        mainAxis: rawOffset,\n        crossAxis: 0\n      } : {\n        mainAxis: 0,\n        crossAxis: 0,\n        ...rawOffset\n      };\n      if (checkMainAxis) {\n        const len = mainAxis === 'y' ? 'height' : 'width';\n        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;\n        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;\n        if (mainAxisCoord < limitMin) {\n          mainAxisCoord = limitMin;\n        } else if (mainAxisCoord > limitMax) {\n          mainAxisCoord = limitMax;\n        }\n      }\n      if (checkCrossAxis) {\n        var _middlewareData$offse, _middlewareData$offse2;\n        const len = mainAxis === 'y' ? 'width' : 'height';\n        const isOriginSide = ['top', 'left'].includes(getSide(placement));\n        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);\n        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);\n        if (crossAxisCoord < limitMin) {\n          crossAxisCoord = limitMin;\n        } else if (crossAxisCoord > limitMax) {\n          crossAxisCoord = limitMax;\n        }\n      }\n      return {\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      };\n    }\n  };\n};\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'size',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const maximumClippingHeight = height - overflow.top - overflow.bottom;\n      const maximumClippingWidth = width - overflow.left - overflow.right;\n      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);\n      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if (isYAxis) {\n        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;\n      } else {\n        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;\n      }\n      if (noShift && !alignment) {\n        const xMin = max(overflow.left, 0);\n        const xMax = max(overflow.right, 0);\n        const yMin = max(overflow.top, 0);\n        const yMax = max(overflow.bottom, 0);\n        if (isYAxis) {\n          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));\n        } else {\n          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));\n        }\n      }\n      await apply({\n        ...state,\n        availableWidth,\n        availableHeight\n      });\n      const nextDimensions = await platform.getDimensions(elements.floating);\n      if (width !== nextDimensions.width || height !== nextDimensions.height) {\n        return {\n          reset: {\n            rects: true\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nexport { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, shift, size };\n","function getNodeName(node) {\n  if (isNode(node)) {\n    return (node.nodeName || '').toLowerCase();\n  }\n  // Mocked nodes in testing environments may not be instances of Node. By\n  // returning `#document` an infinite loop won't occur.\n  // https://github.com/floating-ui/floating-ui/issues/2317\n  return '#document';\n}\nfunction getWindow(node) {\n  var _node$ownerDocument;\n  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\nfunction getDocumentElement(node) {\n  var _ref;\n  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;\n}\nfunction isNode(value) {\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  // Browsers without `ShadowRoot` support.\n  if (typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle(element);\n  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isTopLayer(element) {\n  return [':popover-open', ':modal'].some(selector => {\n    try {\n      return element.matches(selector);\n    } catch (e) {\n      return false;\n    }\n  });\n}\nfunction isContainingBlock(elementOrCss) {\n  const webkit = isWebKit();\n  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else if (isTopLayer(currentNode)) {\n      return null;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.scrollX,\n    scrollTop: element.scrollY\n  };\n}\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\nfunction getOverflowAncestors(node, list, traverseIframes) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\n  }\n  if (traverseIframes === void 0) {\n    traverseIframes = true;\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    const frameElement = getFrameElement(win);\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\nfunction getFrameElement(win) {\n  return Object.getPrototypeOf(win.parent) ? win.frameElement : null;\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };\n","import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getFrameElement, getDocumentElement, isTopLayer, getNodeName, isOverflowElement, getNodeScroll, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';\nexport { getOverflowAncestors } from '@floating-ui/utils/dom';\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createCoords(0);\nfunction getVisualOffsets(element) {\n  const win = getWindow(element);\n  if (!isWebKit() || !win.visualViewport) {\n    return noOffsets;\n  }\n  return {\n    x: win.visualViewport.offsetLeft,\n    y: win.visualViewport.offsetTop\n  };\n}\nfunction shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {\n    return false;\n  }\n  return isFixed;\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentWin = win;\n    let currentIFrame = getFrameElement(currentWin);\n    while (currentIFrame && offsetParent && offsetWin !== currentWin) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentWin = getWindow(currentIFrame);\n      currentIFrame = getFrameElement(currentWin);\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isFixed = strategy === 'fixed';\n  const documentElement = getDocumentElement(offsetParent);\n  const topLayer = elements ? isTopLayer(elements.floating) : false;\n  if (offsetParent === documentElement || topLayer && isFixed) {\n    return rect;\n  }\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  let scale = createCoords(1);\n  const offsets = createCoords(0);\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent);\n      scale = getScale(offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    }\n  }\n  return {\n    width: rect.width * scale.x,\n    height: rect.height * scale.y,\n    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\n}\n\nfunction getWindowScrollBarX(element) {\n  // If <html> has a CSS width greater than the viewport, then this will be\n  // incorrect for RTL.\n  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;\n}\n\n// Gets the entire size of the scrollable document area, even extending outside\n// of the `<html>` and `<body>` rect bounds if horizontally scrollable.\nfunction getDocumentRect(element) {\n  const html = getDocumentElement(element);\n  const scroll = getNodeScroll(element);\n  const body = element.ownerDocument.body;\n  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);\n  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);\n  let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n  const y = -scroll.scrollTop;\n  if (getComputedStyle(body).direction === 'rtl') {\n    x += max(html.clientWidth, body.clientWidth) - width;\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\nfunction getViewportRect(element, strategy) {\n  const win = getWindow(element);\n  const html = getDocumentElement(element);\n  const visualViewport = win.visualViewport;\n  let width = html.clientWidth;\n  let height = html.clientHeight;\n  let x = 0;\n  let y = 0;\n  if (visualViewport) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n    const visualViewportBased = isWebKit();\n    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {\n      x = visualViewport.offsetLeft;\n      y = visualViewport.offsetTop;\n    }\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\n// Returns the inner client rect, subtracting scrollbars if present.\nfunction getInnerBoundingClientRect(element, strategy) {\n  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');\n  const top = clientRect.top + element.clientTop;\n  const left = clientRect.left + element.clientLeft;\n  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);\n  const width = element.clientWidth * scale.x;\n  const height = element.clientHeight * scale.y;\n  const x = left * scale.x;\n  const y = top * scale.y;\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\nfunction getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {\n  let rect;\n  if (clippingAncestor === 'viewport') {\n    rect = getViewportRect(element, strategy);\n  } else if (clippingAncestor === 'document') {\n    rect = getDocumentRect(getDocumentElement(element));\n  } else if (isElement(clippingAncestor)) {\n    rect = getInnerBoundingClientRect(clippingAncestor, strategy);\n  } else {\n    const visualOffsets = getVisualOffsets(element);\n    rect = {\n      ...clippingAncestor,\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y\n    };\n  }\n  return rectToClientRect(rect);\n}\nfunction hasFixedPositionAncestor(element, stopNode) {\n  const parentNode = getParentNode(element);\n  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {\n    return false;\n  }\n  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);\n}\n\n// A \"clipping ancestor\" is an `overflow` element with the characteristic of\n// clipping (or hiding) child elements. This returns all clipping ancestors\n// of the given element up the tree.\nfunction getClippingElementAncestors(element, cache) {\n  const cachedResult = cache.get(element);\n  if (cachedResult) {\n    return cachedResult;\n  }\n  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');\n  let currentContainingBlockComputedStyle = null;\n  const elementIsFixed = getComputedStyle(element).position === 'fixed';\n  let currentNode = elementIsFixed ? getParentNode(element) : element;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    const computedStyle = getComputedStyle(currentNode);\n    const currentNodeIsContaining = isContainingBlock(currentNode);\n    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {\n      currentContainingBlockComputedStyle = null;\n    }\n    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);\n    if (shouldDropCurrentNode) {\n      // Drop non-containing blocks.\n      result = result.filter(ancestor => ancestor !== currentNode);\n    } else {\n      // Record last containing block for next iteration.\n      currentContainingBlockComputedStyle = computedStyle;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  cache.set(element, result);\n  return result;\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors.\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  const {\n    width,\n    height\n  } = getCssDimensions(element);\n  return {\n    width,\n    height\n  };\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isOffsetParentAnElement) {\n      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n  const x = rect.left + scroll.scrollLeft - offsets.x;\n  const y = rect.top + scroll.scrollTop - offsets.y;\n  return {\n    x,\n    y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction isStaticPositioned(element) {\n  return getComputedStyle(element).position === 'static';\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  return element.offsetParent;\n}\n\n// Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\nfunction getOffsetParent(element, polyfill) {\n  const win = getWindow(element);\n  if (isTopLayer(element)) {\n    return win;\n  }\n  if (!isHTMLElement(element)) {\n    let svgOffsetParent = getParentNode(element);\n    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {\n      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {\n        return svgOffsetParent;\n      }\n      svgOffsetParent = getParentNode(svgOffsetParent);\n    }\n    return win;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {\n    return win;\n  }\n  return offsetParent || getContainingBlock(element) || win;\n}\n\nconst getElementRects = async function (data) {\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  const floatingDimensions = await getDimensionsFn(data.floating);\n  return {\n    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      width: floatingDimensions.width,\n      height: floatingDimensions.height\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    var _io;\n    clearTimeout(timeoutId);\n    (_io = io) == null || _io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = element.getBoundingClientRect();\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          // If the reference is clipped, the ratio is 0. Throttle the refresh\n          // to prevent an infinite loop of updates.\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 1000);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          var _resizeObserver;\n          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    var _resizeObserver2;\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo == null || cleanupIo();\n    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nconst detectOverflow = detectOverflow$1;\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = offset$1;\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = autoPlacement$1;\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = shift$1;\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = flip$1;\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = size$1;\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = hide$1;\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = arrow$1;\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = inline$1;\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = limitShift$1;\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n */\nconst computePosition = (reference, floating, options) => {\n  // This caches the expensive `getClippingElementAncestors` function so that\n  // multiple lifecycle resets re-use the same result. It only lives for a\n  // single call. If other functions become expensive, we can add them as well.\n  const cache = new Map();\n  const mergedOptions = {\n    platform,\n    ...options\n  };\n  const platformWithCache = {\n    ...mergedOptions.platform,\n    _c: cache\n  };\n  return computePosition$1(reference, floating, {\n    ...mergedOptions,\n    platform: platformWithCache\n  });\n};\n\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };\n","/*\n* React Tooltip\n* {@link https://github.com/ReactTooltip/react-tooltip}\n* @copyright ReactTooltip Team\n* @license MIT\n*/\nimport e,{useLayoutEffect as t,useEffect as o,createContext as l,useState as r,useCallback as n,useMemo as i,useContext as c,useRef as s,useImperativeHandle as a}from\"react\";import{arrow as u,computePosition as d,offset as p,flip as v,shift as m,autoUpdate as f}from\"@floating-ui/dom\";import y from\"classnames\";const h=\"react-tooltip-core-styles\",w=\"react-tooltip-base-styles\",b={core:!1,base:!1};function S({css:e,id:t=w,type:o=\"base\",ref:l}){var r,n;if(!e||\"undefined\"==typeof document||b[o])return;if(\"core\"===o&&\"undefined\"!=typeof process&&(null===(r=null===process||void 0===process?void 0:process.env)||void 0===r?void 0:r.REACT_TOOLTIP_DISABLE_CORE_STYLES))return;if(\"base\"!==o&&\"undefined\"!=typeof process&&(null===(n=null===process||void 0===process?void 0:process.env)||void 0===n?void 0:n.REACT_TOOLTIP_DISABLE_BASE_STYLES))return;\"core\"===o&&(t=h),l||(l={});const{insertAt:i}=l;if(document.getElementById(t))return;const c=document.head||document.getElementsByTagName(\"head\")[0],s=document.createElement(\"style\");s.id=t,s.type=\"text/css\",\"top\"===i&&c.firstChild?c.insertBefore(s,c.firstChild):c.appendChild(s),s.styleSheet?s.styleSheet.cssText=e:s.appendChild(document.createTextNode(e)),b[o]=!0}function g({type:e=\"base\",id:t=w}={}){if(!b[e])return;\"core\"===e&&(t=h);const o=document.getElementById(t);\"style\"===(null==o?void 0:o.tagName)?null==o||o.remove():console.warn(`[react-tooltip] Failed to remove 'style' element with id '${t}'. Call \\`injectStyle()\\` first`),b[e]=!1}const E=async({elementReference:e=null,tooltipReference:t=null,tooltipArrowReference:o=null,place:l=\"top\",offset:r=10,strategy:n=\"absolute\",middlewares:i=[p(Number(r)),v({fallbackAxisSideDirection:\"start\"}),m({padding:5})],border:c})=>{if(!e)return{tooltipStyles:{},tooltipArrowStyles:{},place:l};if(null===t)return{tooltipStyles:{},tooltipArrowStyles:{},place:l};const s=i;return o?(s.push(u({element:o,padding:5})),d(e,t,{placement:l,strategy:n,middleware:s}).then((({x:e,y:t,placement:o,middlewareData:l})=>{var r,n;const i={left:`${e}px`,top:`${t}px`,border:c},{x:s,y:a}=null!==(r=l.arrow)&&void 0!==r?r:{x:0,y:0},u=null!==(n={top:\"bottom\",right:\"left\",bottom:\"top\",left:\"right\"}[o.split(\"-\")[0]])&&void 0!==n?n:\"bottom\",d=c&&{borderBottom:c,borderRight:c};let p=0;if(c){const e=`${c}`.match(/(\\d+)px/);p=(null==e?void 0:e[1])?Number(e[1]):1}return{tooltipStyles:i,tooltipArrowStyles:{left:null!=s?`${s}px`:\"\",top:null!=a?`${a}px`:\"\",right:\"\",bottom:\"\",...d,[u]:`-${4+p}px`},place:o}}))):d(e,t,{placement:\"bottom\",strategy:n,middleware:s}).then((({x:e,y:t,placement:o})=>({tooltipStyles:{left:`${e}px`,top:`${t}px`},tooltipArrowStyles:{},place:o})))},A=(e,t)=>!(\"CSS\"in window&&\"supports\"in window.CSS)||window.CSS.supports(e,t),_=(e,t,o)=>{let l=null;const r=function(...r){const n=()=>{l=null,o||e.apply(this,r)};o&&!l&&(e.apply(this,r),l=setTimeout(n,t)),o||(l&&clearTimeout(l),l=setTimeout(n,t))};return r.cancel=()=>{l&&(clearTimeout(l),l=null)},r},O=e=>null!==e&&!Array.isArray(e)&&\"object\"==typeof e,k=(e,t)=>{if(e===t)return!0;if(Array.isArray(e)&&Array.isArray(t))return e.length===t.length&&e.every(((e,o)=>k(e,t[o])));if(Array.isArray(e)!==Array.isArray(t))return!1;if(!O(e)||!O(t))return e===t;const o=Object.keys(e),l=Object.keys(t);return o.length===l.length&&o.every((o=>k(e[o],t[o])))},T=e=>{if(!(e instanceof HTMLElement||e instanceof SVGElement))return!1;const t=getComputedStyle(e);return[\"overflow\",\"overflow-x\",\"overflow-y\"].some((e=>{const o=t.getPropertyValue(e);return\"auto\"===o||\"scroll\"===o}))},L=e=>{if(!e)return null;let t=e.parentElement;for(;t;){if(T(t))return t;t=t.parentElement}return document.scrollingElement||document.documentElement},C=\"undefined\"!=typeof window?t:o,R=e=>{e.current&&(clearTimeout(e.current),e.current=null)},x=\"DEFAULT_TOOLTIP_ID\",N={anchorRefs:new Set,activeAnchor:{current:null},attach:()=>{},detach:()=>{},setActiveAnchor:()=>{}},$=l({getTooltipData:()=>N}),I=({children:t})=>{const[o,l]=r({[x]:new Set}),[c,s]=r({[x]:{current:null}}),a=(e,...t)=>{l((o=>{var l;const r=null!==(l=o[e])&&void 0!==l?l:new Set;return t.forEach((e=>r.add(e))),{...o,[e]:new Set(r)}}))},u=(e,...t)=>{l((o=>{const l=o[e];return l?(t.forEach((e=>l.delete(e))),{...o}):o}))},d=n(((e=x)=>{var t,l;return{anchorRefs:null!==(t=o[e])&&void 0!==t?t:new Set,activeAnchor:null!==(l=c[e])&&void 0!==l?l:{current:null},attach:(...t)=>a(e,...t),detach:(...t)=>u(e,...t),setActiveAnchor:t=>((e,t)=>{s((o=>{var l;return(null===(l=o[e])||void 0===l?void 0:l.current)===t.current?o:{...o,[e]:t}}))})(e,t)}}),[o,c,a,u]),p=i((()=>({getTooltipData:d})),[d]);return e.createElement($.Provider,{value:p},t)};function j(e=x){return c($).getTooltipData(e)}const B=({tooltipId:t,children:l,className:r,place:n,content:i,html:c,variant:a,offset:u,wrapper:d,events:p,positionStrategy:v,delayShow:m,delayHide:f})=>{const{attach:h,detach:w}=j(t),b=s(null);return o((()=>(h(b),()=>{w(b)})),[]),e.createElement(\"span\",{ref:b,className:y(\"react-tooltip-wrapper\",r),\"data-tooltip-place\":n,\"data-tooltip-content\":i,\"data-tooltip-html\":c,\"data-tooltip-variant\":a,\"data-tooltip-offset\":u,\"data-tooltip-wrapper\":d,\"data-tooltip-events\":p,\"data-tooltip-position-strategy\":v,\"data-tooltip-delay-show\":m,\"data-tooltip-delay-hide\":f},l)};var z={tooltip:\"core-styles-module_tooltip__3vRRp\",fixed:\"core-styles-module_fixed__pcSol\",arrow:\"core-styles-module_arrow__cvMwQ\",noArrow:\"core-styles-module_noArrow__xock6\",clickable:\"core-styles-module_clickable__ZuTTB\",show:\"core-styles-module_show__Nt9eE\",closing:\"core-styles-module_closing__sGnxF\"},D={tooltip:\"styles-module_tooltip__mnnfp\",arrow:\"styles-module_arrow__K0L3T\",dark:\"styles-module_dark__xNqje\",light:\"styles-module_light__Z6W-X\",success:\"styles-module_success__A2AKt\",warning:\"styles-module_warning__SCK0X\",error:\"styles-module_error__JvumD\",info:\"styles-module_info__BWdHW\"};const q=({forwardRef:t,id:l,className:i,classNameArrow:c,variant:u=\"dark\",anchorId:d,anchorSelect:p,place:v=\"top\",offset:m=10,events:h=[\"hover\"],openOnClick:w=!1,positionStrategy:b=\"absolute\",middlewares:S,wrapper:g,delayShow:A=0,delayHide:O=0,float:T=!1,hidden:x=!1,noArrow:N=!1,clickable:$=!1,closeOnEsc:I=!1,closeOnScroll:B=!1,closeOnResize:q=!1,openEvents:H,closeEvents:M,globalCloseEvents:W,imperativeModeOnly:P,style:V,position:F,afterShow:K,afterHide:U,disableTooltip:X,content:Y,contentWrapperRef:G,isOpen:Z,defaultIsOpen:J=!1,setIsOpen:Q,activeAnchor:ee,setActiveAnchor:te,border:oe,opacity:le,arrowColor:re,role:ne=\"tooltip\"})=>{var ie;const ce=s(null),se=s(null),ae=s(null),ue=s(null),de=s(null),[pe,ve]=r({tooltipStyles:{},tooltipArrowStyles:{},place:v}),[me,fe]=r(!1),[ye,he]=r(!1),[we,be]=r(null),Se=s(!1),ge=s(null),{anchorRefs:Ee,setActiveAnchor:Ae}=j(l),_e=s(!1),[Oe,ke]=r([]),Te=s(!1),Le=w||h.includes(\"click\"),Ce=Le||(null==H?void 0:H.click)||(null==H?void 0:H.dblclick)||(null==H?void 0:H.mousedown),Re=H?{...H}:{mouseover:!0,focus:!0,mouseenter:!1,click:!1,dblclick:!1,mousedown:!1};!H&&Le&&Object.assign(Re,{mouseenter:!1,focus:!1,mouseover:!1,click:!0});const xe=M?{...M}:{mouseout:!0,blur:!0,mouseleave:!1,click:!1,dblclick:!1,mouseup:!1};!M&&Le&&Object.assign(xe,{mouseleave:!1,blur:!1,mouseout:!1});const Ne=W?{...W}:{escape:I||!1,scroll:B||!1,resize:q||!1,clickOutsideAnchor:Ce||!1};P&&(Object.assign(Re,{mouseenter:!1,focus:!1,click:!1,dblclick:!1,mousedown:!1}),Object.assign(xe,{mouseleave:!1,blur:!1,click:!1,dblclick:!1,mouseup:!1}),Object.assign(Ne,{escape:!1,scroll:!1,resize:!1,clickOutsideAnchor:!1})),C((()=>(Te.current=!0,()=>{Te.current=!1})),[]);const $e=e=>{Te.current&&(e&&he(!0),setTimeout((()=>{Te.current&&(null==Q||Q(e),void 0===Z&&fe(e))}),10))};o((()=>{if(void 0===Z)return()=>null;Z&&he(!0);const e=setTimeout((()=>{fe(Z)}),10);return()=>{clearTimeout(e)}}),[Z]),o((()=>{if(me!==Se.current)if(R(de),Se.current=me,me)null==K||K();else{const e=(e=>{const t=e.match(/^([\\d.]+)(ms|s)$/);if(!t)return 0;const[,o,l]=t;return Number(o)*(\"ms\"===l?1:1e3)})(getComputedStyle(document.body).getPropertyValue(\"--rt-transition-show-delay\"));de.current=setTimeout((()=>{he(!1),be(null),null==U||U()}),e+25)}}),[me]);const Ie=e=>{ve((t=>k(t,e)?t:e))},je=(e=A)=>{R(ae),ye?$e(!0):ae.current=setTimeout((()=>{$e(!0)}),e)},Be=(e=O)=>{R(ue),ue.current=setTimeout((()=>{_e.current||$e(!1)}),e)},ze=e=>{var t;if(!e)return;const o=null!==(t=e.currentTarget)&&void 0!==t?t:e.target;if(!(null==o?void 0:o.isConnected))return te(null),void Ae({current:null});A?je():$e(!0),te(o),Ae({current:o}),R(ue)},De=()=>{$?Be(O||100):O?Be():$e(!1),R(ae)},qe=({x:e,y:t})=>{var o;const l={getBoundingClientRect:()=>({x:e,y:t,width:0,height:0,top:t,left:e,right:e,bottom:t})};E({place:null!==(o=null==we?void 0:we.place)&&void 0!==o?o:v,offset:m,elementReference:l,tooltipReference:ce.current,tooltipArrowReference:se.current,strategy:b,middlewares:S,border:oe}).then((e=>{Ie(e)}))},He=e=>{if(!e)return;const t=e,o={x:t.clientX,y:t.clientY};qe(o),ge.current=o},Me=e=>{var t;if(!me)return;const o=e.target;if(!o.isConnected)return;if(null===(t=ce.current)||void 0===t?void 0:t.contains(o))return;[document.querySelector(`[id='${d}']`),...Oe].some((e=>null==e?void 0:e.contains(o)))||($e(!1),R(ae))},We=_(ze,50,!0),Pe=_(De,50,!0),Ve=e=>{Pe.cancel(),We(e)},Fe=()=>{We.cancel(),Pe()},Ke=n((()=>{var e,t;const o=null!==(e=null==we?void 0:we.position)&&void 0!==e?e:F;o?qe(o):T?ge.current&&qe(ge.current):(null==ee?void 0:ee.isConnected)&&E({place:null!==(t=null==we?void 0:we.place)&&void 0!==t?t:v,offset:m,elementReference:ee,tooltipReference:ce.current,tooltipArrowReference:se.current,strategy:b,middlewares:S,border:oe}).then((e=>{Te.current&&Ie(e)}))}),[me,ee,Y,V,v,null==we?void 0:we.place,m,b,F,null==we?void 0:we.position,T]);o((()=>{var e,t;const o=new Set(Ee);Oe.forEach((e=>{(null==X?void 0:X(e))||o.add({current:e})}));const l=document.querySelector(`[id='${d}']`);l&&!(null==X?void 0:X(l))&&o.add({current:l});const r=()=>{$e(!1)},n=L(ee),i=L(ce.current);Ne.scroll&&(window.addEventListener(\"scroll\",r),null==n||n.addEventListener(\"scroll\",r),null==i||i.addEventListener(\"scroll\",r));let c=null;Ne.resize?window.addEventListener(\"resize\",r):ee&&ce.current&&(c=f(ee,ce.current,Ke,{ancestorResize:!0,elementResize:!0,layoutShift:!0}));const s=e=>{\"Escape\"===e.key&&$e(!1)};Ne.escape&&window.addEventListener(\"keydown\",s),Ne.clickOutsideAnchor&&window.addEventListener(\"click\",Me);const a=[],u=e=>{me&&(null==e?void 0:e.target)===ee||ze(e)},p=e=>{me&&(null==e?void 0:e.target)===ee&&De()},v=[\"mouseover\",\"mouseout\",\"mouseenter\",\"mouseleave\",\"focus\",\"blur\"],m=[\"click\",\"dblclick\",\"mousedown\",\"mouseup\"];Object.entries(Re).forEach((([e,t])=>{t&&(v.includes(e)?a.push({event:e,listener:Ve}):m.includes(e)&&a.push({event:e,listener:u}))})),Object.entries(xe).forEach((([e,t])=>{t&&(v.includes(e)?a.push({event:e,listener:Fe}):m.includes(e)&&a.push({event:e,listener:p}))})),T&&a.push({event:\"pointermove\",listener:He});const y=()=>{_e.current=!0},h=()=>{_e.current=!1,De()};return $&&!Ce&&(null===(e=ce.current)||void 0===e||e.addEventListener(\"mouseenter\",y),null===(t=ce.current)||void 0===t||t.addEventListener(\"mouseleave\",h)),a.forEach((({event:e,listener:t})=>{o.forEach((o=>{var l;null===(l=o.current)||void 0===l||l.addEventListener(e,t)}))})),()=>{var e,t;Ne.scroll&&(window.removeEventListener(\"scroll\",r),null==n||n.removeEventListener(\"scroll\",r),null==i||i.removeEventListener(\"scroll\",r)),Ne.resize?window.removeEventListener(\"resize\",r):null==c||c(),Ne.clickOutsideAnchor&&window.removeEventListener(\"click\",Me),Ne.escape&&window.removeEventListener(\"keydown\",s),$&&!Ce&&(null===(e=ce.current)||void 0===e||e.removeEventListener(\"mouseenter\",y),null===(t=ce.current)||void 0===t||t.removeEventListener(\"mouseleave\",h)),a.forEach((({event:e,listener:t})=>{o.forEach((o=>{var l;null===(l=o.current)||void 0===l||l.removeEventListener(e,t)}))}))}}),[ee,Ke,ye,Ee,Oe,H,M,W,Le,A,O]),o((()=>{var e,t;let o=null!==(t=null!==(e=null==we?void 0:we.anchorSelect)&&void 0!==e?e:p)&&void 0!==t?t:\"\";!o&&l&&(o=`[data-tooltip-id='${l.replace(/'/g,\"\\\\'\")}']`);const r=new MutationObserver((e=>{const t=[],r=[];e.forEach((e=>{if(\"attributes\"===e.type&&\"data-tooltip-id\"===e.attributeName){e.target.getAttribute(\"data-tooltip-id\")===l?t.push(e.target):e.oldValue===l&&r.push(e.target)}if(\"childList\"===e.type){if(ee){const t=[...e.removedNodes].filter((e=>1===e.nodeType));if(o)try{r.push(...t.filter((e=>e.matches(o)))),r.push(...t.flatMap((e=>[...e.querySelectorAll(o)])))}catch(e){}t.some((e=>{var t;return!!(null===(t=null==e?void 0:e.contains)||void 0===t?void 0:t.call(e,ee))&&(he(!1),$e(!1),te(null),R(ae),R(ue),!0)}))}if(o)try{const l=[...e.addedNodes].filter((e=>1===e.nodeType));t.push(...l.filter((e=>e.matches(o)))),t.push(...l.flatMap((e=>[...e.querySelectorAll(o)])))}catch(e){}}})),(t.length||r.length)&&ke((e=>[...e.filter((e=>!r.includes(e))),...t]))}));return r.observe(document.body,{childList:!0,subtree:!0,attributes:!0,attributeFilter:[\"data-tooltip-id\"],attributeOldValue:!0}),()=>{r.disconnect()}}),[l,p,null==we?void 0:we.anchorSelect,ee]),o((()=>{Ke()}),[Ke]),o((()=>{if(!(null==G?void 0:G.current))return()=>null;const e=new ResizeObserver((()=>{setTimeout((()=>Ke()))}));return e.observe(G.current),()=>{e.disconnect()}}),[Y,null==G?void 0:G.current]),o((()=>{var e;const t=document.querySelector(`[id='${d}']`),o=[...Oe,t];ee&&o.includes(ee)||te(null!==(e=Oe[0])&&void 0!==e?e:t)}),[d,Oe,ee]),o((()=>(J&&$e(!0),()=>{R(ae),R(ue)})),[]),o((()=>{var e;let t=null!==(e=null==we?void 0:we.anchorSelect)&&void 0!==e?e:p;if(!t&&l&&(t=`[data-tooltip-id='${l.replace(/'/g,\"\\\\'\")}']`),t)try{const e=Array.from(document.querySelectorAll(t));ke(e)}catch(e){ke([])}}),[l,p,null==we?void 0:we.anchorSelect]),o((()=>{ae.current&&(R(ae),je(A))}),[A]);const Ue=null!==(ie=null==we?void 0:we.content)&&void 0!==ie?ie:Y,Xe=me&&Object.keys(pe.tooltipStyles).length>0;return a(t,(()=>({open:e=>{if(null==e?void 0:e.anchorSelect)try{document.querySelector(e.anchorSelect)}catch(t){return void console.warn(`[react-tooltip] \"${e.anchorSelect}\" is not a valid CSS selector`)}be(null!=e?e:null),(null==e?void 0:e.delay)?je(e.delay):$e(!0)},close:e=>{(null==e?void 0:e.delay)?Be(e.delay):$e(!1)},activeAnchor:ee,place:pe.place,isOpen:Boolean(ye&&!x&&Ue&&Xe)}))),ye&&!x&&Ue?e.createElement(g,{id:l,role:ne,className:y(\"react-tooltip\",z.tooltip,D.tooltip,D[u],i,`react-tooltip__place-${pe.place}`,z[Xe?\"show\":\"closing\"],Xe?\"react-tooltip__show\":\"react-tooltip__closing\",\"fixed\"===b&&z.fixed,$&&z.clickable),onTransitionEnd:e=>{R(de),me||\"opacity\"!==e.propertyName||(he(!1),be(null),null==U||U())},style:{...V,...pe.tooltipStyles,opacity:void 0!==le&&Xe?le:void 0},ref:ce},Ue,e.createElement(g,{className:y(\"react-tooltip-arrow\",z.arrow,D.arrow,c,N&&z.noArrow),style:{...pe.tooltipArrowStyles,background:re?`linear-gradient(to right bottom, transparent 50%, ${re} 50%)`:void 0},ref:se})):null},H=({content:t})=>e.createElement(\"span\",{dangerouslySetInnerHTML:{__html:t}}),M=e.forwardRef((({id:t,anchorId:l,anchorSelect:n,content:i,html:c,render:a,className:u,classNameArrow:d,variant:p=\"dark\",place:v=\"top\",offset:m=10,wrapper:f=\"div\",children:h=null,events:w=[\"hover\"],openOnClick:b=!1,positionStrategy:S=\"absolute\",middlewares:g,delayShow:E=0,delayHide:_=0,float:O=!1,hidden:k=!1,noArrow:T=!1,clickable:L=!1,closeOnEsc:C=!1,closeOnScroll:R=!1,closeOnResize:x=!1,openEvents:N,closeEvents:$,globalCloseEvents:I,imperativeModeOnly:B=!1,style:z,position:D,isOpen:M,defaultIsOpen:W=!1,disableStyleInjection:P=!1,border:V,opacity:F,arrowColor:K,setIsOpen:U,afterShow:X,afterHide:Y,disableTooltip:G,role:Z=\"tooltip\"},J)=>{const[Q,ee]=r(i),[te,oe]=r(c),[le,re]=r(v),[ne,ie]=r(p),[ce,se]=r(m),[ae,ue]=r(E),[de,pe]=r(_),[ve,me]=r(O),[fe,ye]=r(k),[he,we]=r(f),[be,Se]=r(w),[ge,Ee]=r(S),[Ae,_e]=r(null),[Oe,ke]=r(null),Te=s(P),{anchorRefs:Le,activeAnchor:Ce}=j(t),Re=e=>null==e?void 0:e.getAttributeNames().reduce(((t,o)=>{var l;if(o.startsWith(\"data-tooltip-\")){t[o.replace(/^data-tooltip-/,\"\")]=null!==(l=null==e?void 0:e.getAttribute(o))&&void 0!==l?l:null}return t}),{}),xe=e=>{const t={place:e=>{var t;re(null!==(t=e)&&void 0!==t?t:v)},content:e=>{ee(null!=e?e:i)},html:e=>{oe(null!=e?e:c)},variant:e=>{var t;ie(null!==(t=e)&&void 0!==t?t:p)},offset:e=>{se(null===e?m:Number(e))},wrapper:e=>{var t;we(null!==(t=e)&&void 0!==t?t:f)},events:e=>{const t=null==e?void 0:e.split(\" \");Se(null!=t?t:w)},\"position-strategy\":e=>{var t;Ee(null!==(t=e)&&void 0!==t?t:S)},\"delay-show\":e=>{ue(null===e?E:Number(e))},\"delay-hide\":e=>{pe(null===e?_:Number(e))},float:e=>{me(null===e?O:\"true\"===e)},hidden:e=>{ye(null===e?k:\"true\"===e)},\"class-name\":e=>{_e(e)}};Object.values(t).forEach((e=>e(null))),Object.entries(e).forEach((([e,o])=>{var l;null===(l=t[e])||void 0===l||l.call(t,o)}))};o((()=>{ee(i)}),[i]),o((()=>{oe(c)}),[c]),o((()=>{re(v)}),[v]),o((()=>{ie(p)}),[p]),o((()=>{se(m)}),[m]),o((()=>{ue(E)}),[E]),o((()=>{pe(_)}),[_]),o((()=>{me(O)}),[O]),o((()=>{ye(k)}),[k]),o((()=>{Ee(S)}),[S]),o((()=>{Te.current!==P&&console.warn(\"[react-tooltip] Do not change `disableStyleInjection` dynamically.\")}),[P]),o((()=>{\"undefined\"!=typeof window&&window.dispatchEvent(new CustomEvent(\"react-tooltip-inject-styles\",{detail:{disableCore:\"core\"===P,disableBase:P}}))}),[]),o((()=>{var e;const o=new Set(Le);let r=n;if(!r&&t&&(r=`[data-tooltip-id='${t.replace(/'/g,\"\\\\'\")}']`),r)try{document.querySelectorAll(r).forEach((e=>{o.add({current:e})}))}catch(e){console.warn(`[react-tooltip] \"${r}\" is not a valid CSS selector`)}const i=document.querySelector(`[id='${l}']`);if(i&&o.add({current:i}),!o.size)return()=>null;const c=null!==(e=null!=Oe?Oe:i)&&void 0!==e?e:Ce.current,s=new MutationObserver((e=>{e.forEach((e=>{var t;if(!c||\"attributes\"!==e.type||!(null===(t=e.attributeName)||void 0===t?void 0:t.startsWith(\"data-tooltip-\")))return;const o=Re(c);xe(o)}))})),a={attributes:!0,childList:!1,subtree:!1};if(c){const e=Re(c);xe(e),s.observe(c,a)}return()=>{s.disconnect()}}),[Le,Ce,Oe,l,n]),o((()=>{(null==z?void 0:z.border)&&console.warn(\"[react-tooltip] Do not set `style.border`. Use `border` prop instead.\"),V&&!A(\"border\",`${V}`)&&console.warn(`[react-tooltip] \"${V}\" is not a valid \\`border\\`.`),(null==z?void 0:z.opacity)&&console.warn(\"[react-tooltip] Do not set `style.opacity`. Use `opacity` prop instead.\"),F&&!A(\"opacity\",`${F}`)&&console.warn(`[react-tooltip] \"${F}\" is not a valid \\`opacity\\`.`)}),[]);let Ne=h;const $e=s(null);if(a){const t=a({content:(null==Oe?void 0:Oe.getAttribute(\"data-tooltip-content\"))||Q||null,activeAnchor:Oe});Ne=t?e.createElement(\"div\",{ref:$e,className:\"react-tooltip-content-wrapper\"},t):null}else Q&&(Ne=Q);te&&(Ne=e.createElement(H,{content:te}));const Ie={forwardRef:J,id:t,anchorId:l,anchorSelect:n,className:y(u,Ae),classNameArrow:d,content:Ne,contentWrapperRef:$e,place:le,variant:ne,offset:ce,wrapper:he,events:be,openOnClick:b,positionStrategy:ge,middlewares:g,delayShow:ae,delayHide:de,float:ve,hidden:fe,noArrow:T,clickable:L,closeOnEsc:C,closeOnScroll:R,closeOnResize:x,openEvents:N,closeEvents:$,globalCloseEvents:I,imperativeModeOnly:B,style:z,position:D,isOpen:M,defaultIsOpen:W,border:V,opacity:F,arrowColor:K,setIsOpen:U,afterShow:X,afterHide:Y,disableTooltip:G,activeAnchor:Oe,setActiveAnchor:e=>ke(e),role:Z};return e.createElement(q,{...Ie})}));\"undefined\"!=typeof window&&window.addEventListener(\"react-tooltip-inject-styles\",(e=>{e.detail.disableCore||S({css:`:root{--rt-color-white:#fff;--rt-color-dark:#222;--rt-color-success:#8dc572;--rt-color-error:#be6464;--rt-color-warning:#f0ad4e;--rt-color-info:#337ab7;--rt-opacity:0.9;--rt-transition-show-delay:0.15s;--rt-transition-closing-delay:0.15s}.core-styles-module_tooltip__3vRRp{position:absolute;top:0;left:0;pointer-events:none;opacity:0;will-change:opacity}.core-styles-module_fixed__pcSol{position:fixed}.core-styles-module_arrow__cvMwQ{position:absolute;background:inherit}.core-styles-module_noArrow__xock6{display:none}.core-styles-module_clickable__ZuTTB{pointer-events:auto}.core-styles-module_show__Nt9eE{opacity:var(--rt-opacity);transition:opacity var(--rt-transition-show-delay)ease-out}.core-styles-module_closing__sGnxF{opacity:0;transition:opacity var(--rt-transition-closing-delay)ease-in}`,type:\"core\"}),e.detail.disableBase||S({css:`\n.styles-module_tooltip__mnnfp{padding:8px 16px;border-radius:3px;font-size:90%;width:max-content}.styles-module_arrow__K0L3T{width:8px;height:8px}[class*='react-tooltip__place-top']>.styles-module_arrow__K0L3T{transform:rotate(45deg)}[class*='react-tooltip__place-right']>.styles-module_arrow__K0L3T{transform:rotate(135deg)}[class*='react-tooltip__place-bottom']>.styles-module_arrow__K0L3T{transform:rotate(225deg)}[class*='react-tooltip__place-left']>.styles-module_arrow__K0L3T{transform:rotate(315deg)}.styles-module_dark__xNqje{background:var(--rt-color-dark);color:var(--rt-color-white)}.styles-module_light__Z6W-X{background-color:var(--rt-color-white);color:var(--rt-color-dark)}.styles-module_success__A2AKt{background-color:var(--rt-color-success);color:var(--rt-color-white)}.styles-module_warning__SCK0X{background-color:var(--rt-color-warning);color:var(--rt-color-white)}.styles-module_error__JvumD{background-color:var(--rt-color-error);color:var(--rt-color-white)}.styles-module_info__BWdHW{background-color:var(--rt-color-info);color:var(--rt-color-white)}`,type:\"base\"})}));export{M as Tooltip,I as TooltipProvider,B as TooltipWrapper,g as removeStyle};\n"],"names":["hasOwn","hasOwnProperty","classNames","classes","i","arguments","length","arg","appendClass","parseValue","Array","isArray","apply","toString","Object","prototype","includes","key","call","value","newClass","module","exports","default","Math","min","max","round","floor","createCoords","v","x","y","oppositeSideMap","left","right","bottom","top","oppositeAlignmentMap","start","end","clamp","param","placement","split","axis","getAxisLength","getAlignmentAxis","replace","alignment","getOppositePlacement","side","padding","expandPaddingObject","rect","width","height","computeCoordsFromPlacement","_ref","rtl","reference","floating","sideAxis","alignmentAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","async","detectOverflow","state","options","_await$platform$isEle","platform","rects","elements","strategy","boundary","rootBoundary","elementContext","altBoundary","paddingObject","element","clippingClientRect","getClippingRect","isElement","contextElement","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","getNodeName","node","isNode","nodeName","toLowerCase","getWindow","_node$ownerDocument","ownerDocument","defaultView","window","document","documentElement","Node","Element","isHTMLElement","HTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","overflow","overflowX","overflowY","display","test","isTableElement","isTopLayer","some","selector","matches","e","isContainingBlock","elementOrCss","webkit","isWebKit","css","transform","perspective","containerType","backdropFilter","filter","willChange","contain","CSS","supports","isLastTraversableNode","getComputedStyle","getNodeScroll","scrollLeft","scrollTop","scrollX","scrollY","getParentNode","result","assignedSlot","parentNode","host","getNearestOverflowAncestor","body","getOverflowAncestors","list","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","win","frameElement","getFrameElement","concat","visualViewport","getPrototypeOf","parent","getCssDimensions","parseFloat","hasOffset","offsetWidth","offsetHeight","shouldFallback","$","unwrapElement","domElement","getBoundingClientRect","Number","isFinite","noOffsets","getVisualOffsets","offsetLeft","offsetTop","includeScale","isFixedStrategy","clientRect","scale","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getWindowScrollBarX","getClientRectFromClippingAncestor","clippingAncestor","html","clientWidth","clientHeight","visualViewportBased","getViewportRect","scroll","scrollWidth","scrollHeight","direction","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","position","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","isStaticPositioned","getTrueOffsetParent","polyfill","svgOffsetParent","currentNode","getContainingBlock","topLayer","clippingAncestors","cache","cachedResult","get","el","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","ancestor","set","getClippingElementAncestors","this","_c","firstClippingAncestor","clippingRect","reduce","accRect","getElementRects","data","getOffsetParentFn","getDimensionsFn","getDimensions","floatingDimensions","getClientRects","from","isRTL","autoUpdate","update","ancestorScroll","ancestorResize","elementResize","ResizeObserver","layoutShift","IntersectionObserver","animationFrame","referenceEl","ancestors","forEach","addEventListener","passive","cleanupIo","onMove","timeoutId","io","root","cleanup","_io","clearTimeout","disconnect","refresh","skip","threshold","rootMargin","isFirstUpdate","handleObserve","entries","ratio","intersectionRatio","setTimeout","observe","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","target","unobserve","cancelAnimationFrame","requestAnimationFrame","_resizeObserver","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","removeEventListener","name","fn","_middlewareData$offse","_middlewareData$arrow","middlewareData","diffCoords","mainAxisMulti","crossAxisMulti","rawValue","mainAxis","crossAxis","convertValueToCoords","offset","arrow","alignmentOffset","checkMainAxis","checkCrossAxis","limiter","detectOverflowOptions","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","_middlewareData$flip","initialPlacement","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","initialSideAxis","isBasePlacement","oppositePlacement","getExpandedPlacements","hasFallbackAxisSideDirection","push","isStart","lr","rl","tb","bt","getSideList","map","getOppositeAxisPlacements","placements","overflows","overflowsData","flip","sides","mainAlignmentSide","every","_middlewareData$flip2","_overflowsData$filter","nextIndex","index","nextPlacement","reset","resetPlacement","d","sort","a","b","_overflowsData$filter2","currentSideAxis","acc","arrowDimensions","isYAxis","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","shouldAddOffset","centerOffset","Map","mergedOptions","platformWithCache","config","middleware","validMiddleware","Boolean","statefulPlacement","resetCount","nextX","nextY","computePosition","h","w","core","base","S","id","t","type","o","ref","l","r","n","process","env","REACT_TOOLTIP_DISABLE_CORE_STYLES","REACT_TOOLTIP_DISABLE_BASE_STYLES","insertAt","getElementById","c","head","getElementsByTagName","s","createElement","firstChild","insertBefore","appendChild","styleSheet","cssText","createTextNode","E","elementReference","tooltipReference","tooltipArrowReference","place","middlewares","border","tooltipStyles","tooltipArrowStyles","then","u","borderBottom","borderRight","p","match","A","_","cancel","O","k","keys","T","SVGElement","getPropertyValue","L","parentElement","scrollingElement","C","R","current","N","anchorRefs","Set","activeAnchor","attach","detach","setActiveAnchor","getTooltipData","j","z","tooltip","fixed","noArrow","clickable","show","closing","D","dark","light","success","warning","error","info","q","forwardRef","className","classNameArrow","variant","anchorId","anchorSelect","m","events","openOnClick","positionStrategy","wrapper","g","delayShow","delayHide","float","hidden","closeOnEsc","I","closeOnScroll","B","closeOnResize","openEvents","H","closeEvents","M","globalCloseEvents","W","imperativeModeOnly","P","style","V","F","afterShow","K","afterHide","U","disableTooltip","X","content","Y","contentWrapperRef","G","isOpen","Z","defaultIsOpen","J","setIsOpen","Q","ee","te","oe","opacity","le","arrowColor","re","role","ne","ie","ce","se","ae","ue","de","pe","ve","me","fe","ye","he","we","be","Se","ge","Ee","Ae","_e","Oe","ke","Te","Le","Ce","click","dblclick","mousedown","Re","mouseover","focus","mouseenter","assign","xe","mouseout","blur","mouseleave","mouseup","Ne","escape","resize","clickOutsideAnchor","$e","Ie","je","Be","ze","currentTarget","isConnected","De","qe","He","clientX","clientY","Me","contains","querySelector","We","Pe","Ve","Fe","Ke","add","event","listener","MutationObserver","attributeName","getAttribute","oldValue","removedNodes","nodeType","flatMap","querySelectorAll","addedNodes","childList","subtree","attributes","attributeFilter","attributeOldValue","Ue","Xe","open","console","warn","delay","close","onTransitionEnd","propertyName","background","dangerouslySetInnerHTML","__html","render","f","children","disableStyleInjection","getAttributeNames","startsWith","values","dispatchEvent","CustomEvent","detail","disableCore","disableBase","size"],"sourceRoot":""}