{"version":3,"file":"DCdH0zmQ.mjs","sources":["../../../../../../node_modules/@melt-ui/svelte/dist/internal/helpers/id.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/helpers/polygon/hull.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/helpers/polygon/index.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/helpers/elements.js","../../../../../../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","../../../../../../node_modules/@floating-ui/core/dist/floating-ui.core.mjs","../../../../../../node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs","../../../../../../node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","../../../../../../node_modules/@melt-ui/svelte/dist/internal/actions/floating/action.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/actions/portal.js","../../../../../../node_modules/@melt-ui/svelte/dist/builders/tooltip/create.js","../../../../../../node_modules/bits-ui/dist/internal/events.js","../../../../../../node_modules/bits-ui/dist/bits/floating/helpers.js","../../../../../../node_modules/bits-ui/dist/bits/tooltip/ctx.js","../../../../../../node_modules/bits-ui/dist/bits/tooltip/components/tooltip.svelte","../../../../../../node_modules/bits-ui/dist/bits/tooltip/components/tooltip-content.svelte","../../../../../../node_modules/bits-ui/dist/bits/tooltip/components/tooltip-trigger.svelte","../../../../../../src/lib/components/reusable/WithTooltip.svelte"],"sourcesContent":["import { nanoid } from 'nanoid/non-secure';\n/**\n * A function that generates a random id\n * @returns An id\n */\nexport function generateId() {\n    return nanoid(10);\n}\nexport function generateIds(args) {\n    return args.reduce((acc, curr) => {\n        acc[curr] = generateId();\n        return acc;\n    }, {});\n}\nexport function stringifiedIdObjType(args) {\n    return `Record<${args.map((arg) => `\"${arg}\"`).join(' | ')}, string>`;\n}\n","/*\n * Convex hull algorithm - Library (TypeScript)\n *\n * Copyright (c) 2021 Project Nayuki\n * https://www.nayuki.io/page/convex-hull-algorithm\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program (see COPYING.txt and COPYING.LESSER.txt).\n * If not, see <http://www.gnu.org/licenses/>.\n */\n// Returns a new array of points representing the convex hull of\n// the given set of points. The convex hull excludes collinear points.\n// This algorithm runs in O(n log n) time.\nexport function makeHull(points) {\n    const newPoints = points.slice();\n    newPoints.sort(POINT_COMPARATOR);\n    return makeHullPresorted(newPoints);\n}\n// Returns the convex hull, assuming that each points[i] <= points[i + 1]. Runs in O(n) time.\nexport function makeHullPresorted(points) {\n    if (points.length <= 1)\n        return points.slice();\n    // Andrew's monotone chain algorithm. Positive y coordinates correspond to \"up\"\n    // as per the mathematical convention, instead of \"down\" as per the computer\n    // graphics convention. This doesn't affect the correctness of the result.\n    const upperHull = [];\n    for (let i = 0; i < points.length; i++) {\n        const p = points[i];\n        while (upperHull.length >= 2) {\n            const q = upperHull[upperHull.length - 1];\n            const r = upperHull[upperHull.length - 2];\n            if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x))\n                upperHull.pop();\n            else\n                break;\n        }\n        upperHull.push(p);\n    }\n    upperHull.pop();\n    const lowerHull = [];\n    for (let i = points.length - 1; i >= 0; i--) {\n        const p = points[i];\n        while (lowerHull.length >= 2) {\n            const q = lowerHull[lowerHull.length - 1];\n            const r = lowerHull[lowerHull.length - 2];\n            if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x))\n                lowerHull.pop();\n            else\n                break;\n        }\n        lowerHull.push(p);\n    }\n    lowerHull.pop();\n    if (upperHull.length == 1 &&\n        lowerHull.length == 1 &&\n        upperHull[0].x == lowerHull[0].x &&\n        upperHull[0].y == lowerHull[0].y)\n        return upperHull;\n    else\n        return upperHull.concat(lowerHull);\n}\nexport function POINT_COMPARATOR(a, b) {\n    if (a.x < b.x)\n        return -1;\n    else if (a.x > b.x)\n        return +1;\n    else if (a.y < b.y)\n        return -1;\n    else if (a.y > b.y)\n        return +1;\n    else\n        return 0;\n}\n","export * from './hull.js';\nimport { makeHull } from './hull.js';\nexport function getPointsFromEl(el) {\n    const rect = el.getBoundingClientRect();\n    return [\n        { x: rect.left, y: rect.top },\n        { x: rect.right, y: rect.top },\n        { x: rect.right, y: rect.bottom },\n        { x: rect.left, y: rect.bottom },\n    ];\n}\nexport function makeHullFromElements(els) {\n    const points = els.flatMap((el) => getPointsFromEl(el));\n    return makeHull(points);\n}\nexport function pointInPolygon(point, polygon) {\n    let inside = false;\n    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {\n        const xi = polygon[i].x;\n        const yi = polygon[i].y;\n        const xj = polygon[j].x;\n        const yj = polygon[j].y;\n        const intersect = yi > point.y !== yj > point.y && point.x < ((xj - xi) * (point.y - yi)) / (yj - yi) + xi;\n        if (intersect)\n            inside = !inside;\n    }\n    return inside;\n}\n","import { isHTMLElement } from './is.js';\n/**\n * Get an element's ancestor which has a `data-portal` attribute.\n * This is used to handle nested portals/overlays/dialogs/popovers.\n */\nfunction getPortalParent(node) {\n    let parent = node.parentElement;\n    while (isHTMLElement(parent) && !parent.hasAttribute('data-portal')) {\n        parent = parent.parentElement;\n    }\n    return parent || 'body';\n}\n/**\n * Gets the destination for a portal given the node and a user-specified portal prop.\n * If a portal prop is not `undefined`, it is used as the destination.\n */\nexport function getPortalDestination(node, portalProp) {\n    // user-specified portal prop, use it\n    if (portalProp !== undefined)\n        return portalProp;\n    // find the closest portal parent, or the body if none is found\n    const portalParent = getPortalParent(node);\n    // if the portalParent is the body, we portal to the body\n    // making it a \"top-level\" portal\n    if (portalParent === 'body')\n        return document.body;\n    // if the portalParent is not the body, we have a portal parent\n    // and shouldn't portal to anything so it remains within that parent\n    // so we return `null`\n    return null;\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};\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  const firstChar = placement[0];\n  return firstChar === 't' || firstChar === 'b' ? '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.includes('start') ? placement.replace('start', 'end') : placement.replace('end', 'start');\n}\nconst lrPlacement = ['left', 'right'];\nconst rlPlacement = ['right', 'left'];\nconst tbPlacement = ['top', 'bottom'];\nconst btPlacement = ['bottom', 'top'];\nfunction getSideList(side, isStart, rtl) {\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rlPlacement : lrPlacement;\n      return isStart ? lrPlacement : rlPlacement;\n    case 'left':\n    case 'right':\n      return isStart ? tbPlacement : btPlacement;\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  const side = getSide(placement);\n  return oppositeSideMap[side] + placement.slice(side.length);\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 * 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// Maximum number of resets that can occur before bailing to avoid infinite reset loops.\nconst MAX_RESET_COUNT = 50;\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 platformWithDetectOverflow = platform.detectOverflow ? platform : {\n    ...platform,\n    detectOverflow\n  };\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 resetCount = 0;\n  const middlewareData = {};\n  for (let i = 0; i < middleware.length; i++) {\n    const currentMiddleware = middleware[i];\n    if (!currentMiddleware) {\n      continue;\n    }\n    const {\n      name,\n      fn\n    } = currentMiddleware;\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: platformWithDetectOverflow,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData[name] = {\n      ...middlewareData[name],\n      ...data\n    };\n    if (reset && resetCount < MAX_RESET_COUNT) {\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 * 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 platform.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 platform.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          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== getSideAxis(nextPlacement) : false;\n          if (!ignoreCrossAxisOverflow ||\n          // We leave the current main axis only if every placement on that axis\n          // overflows the main axis.\n          overflowsData.every(d => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {\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\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        platform\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await platform.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 platform.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\nconst originSides = /*#__PURE__*/new Set(['left', 'top']);\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 = originSides.has(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: rawValue.mainAxis || 0,\n    crossAxis: rawValue.crossAxis || 0,\n    alignmentAxis: rawValue.alignmentAxis\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        platform\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 platform.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          enabled: {\n            [mainAxis]: checkMainAxis,\n            [crossAxis]: checkCrossAxis\n          }\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 = originSides.has(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      var _state$middlewareData, _state$middlewareData2;\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 platform.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 ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {\n        availableWidth = maximumClippingWidth;\n      }\n      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {\n        availableHeight = 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 hasWindow() {\n  return typeof window !== 'undefined';\n}\nfunction 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  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  if (!hasWindow() || 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) && display !== 'inline' && display !== 'contents';\n}\nfunction isTableElement(element) {\n  return /^(table|td|th)$/.test(getNodeName(element));\n}\nfunction isTopLayer(element) {\n  try {\n    if (element.matches(':popover-open')) {\n      return true;\n    }\n  } catch (_e) {\n    // no-op\n  }\n  try {\n    return element.matches(':modal');\n  } catch (_e) {\n    return false;\n  }\n}\nconst willChangeRe = /transform|translate|scale|rotate|perspective|filter/;\nconst containRe = /paint|layout|strict|content/;\nconst isNotNone = value => !!value && value !== 'none';\nlet isWebKitValue;\nfunction isContainingBlock(elementOrCss) {\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  // https://drafts.csswg.org/css-transforms-2/#individual-transforms\n  return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || '') || containRe.test(css.contain || '');\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 (isWebKitValue == null) {\n    isWebKitValue = typeof CSS !== 'undefined' && CSS.supports && CSS.supports('-webkit-backdrop-filter', 'none');\n  }\n  return isWebKitValue;\n}\nfunction isLastTraversableNode(node) {\n  return /^(html|body|#document)$/.test(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  } else {\n    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n  }\n}\nfunction getFrameElement(win) {\n  return win.parent && 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, arrow as arrow$1, autoPlacement as autoPlacement$1, detectOverflow as detectOverflow$1, flip as flip$1, hide as hide$1, inline as inline$1, limitShift as limitShift$1, offset as offset$1, shift as shift$1, size as size$1, computePosition as computePosition$1 } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle as getComputedStyle$1, isHTMLElement, isElement, getWindow, isWebKit, getFrameElement, getNodeScroll, getDocumentElement, isTopLayer, getNodeName, isOverflowElement, 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$1(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$1(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\n// If <html> has a CSS width greater than the viewport, then this will be\n// incorrect for RTL.\nfunction getWindowScrollBarX(element, rect) {\n  const leftScroll = getNodeScroll(element).scrollLeft;\n  if (!rect) {\n    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;\n  }\n  return rect.left + leftScroll;\n}\n\nfunction getHTMLOffset(documentElement, scroll) {\n  const htmlRect = documentElement.getBoundingClientRect();\n  const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);\n  const y = htmlRect.top + scroll.scrollTop;\n  return {\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 (isOffsetParentAnElement) {\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  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);\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 + htmlOffset.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\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$1(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\n// Safety check: ensure the scrollbar space is reasonable in case this\n// calculation is affected by unusual styles.\n// Most scrollbars leave 15-18px of space.\nconst SCROLLBAR_MAX = 25;\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  const windowScrollbarX = getWindowScrollBarX(html);\n  // <html> `overflow: hidden` + `scrollbar-gutter: stable` reduces the\n  // visual width of the <html> but this is not considered in the size\n  // of `html.clientWidth`.\n  if (windowScrollbarX <= 0) {\n    const doc = html.ownerDocument;\n    const body = doc.body;\n    const bodyStyles = getComputedStyle(body);\n    const bodyMarginInline = doc.compatMode === 'CSS1Compat' ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;\n    const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);\n    if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) {\n      width -= clippingStableScrollbarWidth;\n    }\n  } else if (windowScrollbarX <= SCROLLBAR_MAX) {\n    // If the <body> scrollbar is on the left, the width needs to be extended\n    // by the scrollbar amount so there isn't extra space on the right.\n    width += windowScrollbarX;\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      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y,\n      width: clippingAncestor.width,\n      height: clippingAncestor.height\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$1(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$1(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$1(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 && (currentContainingBlockComputedStyle.position === 'absolute' || currentContainingBlockComputedStyle.position === 'fixed') || 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 firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);\n  let top = firstRect.top;\n  let right = firstRect.right;\n  let bottom = firstRect.bottom;\n  let left = firstRect.left;\n  for (let i = 1; i < clippingAncestors.length; i++) {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);\n    top = max(rect.top, top);\n    right = min(rect.right, right);\n    bottom = min(rect.bottom, bottom);\n    left = max(rect.left, left);\n  }\n  return {\n    width: right - left,\n    height: bottom - top,\n    x: left,\n    y: 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\n  // If the <body> scrollbar appears on the left (e.g. RTL systems). Use\n  // Firefox with layout.scrollbar.side = 3 in about:config to test this.\n  function setLeftRTLScrollbarOffset() {\n    offsets.x = getWindowScrollBarX(documentElement);\n  }\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      setLeftRTLScrollbarOffset();\n    }\n  }\n  if (isFixed && !isOffsetParentAnElement && documentElement) {\n    setLeftRTLScrollbarOffset();\n  }\n  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);\n  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;\n  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;\n  return {\n    x,\n    y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction isStaticPositioned(element) {\n  return getComputedStyle$1(element).position === 'static';\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  let rawOffsetParent = element.offsetParent;\n\n  // Firefox returns the <html> element as the offsetParent if it's non-static,\n  // while Chrome and Safari return the <body> element. The <body> element must\n  // be used to perform the correct calculations even if the <html> element is\n  // non-static.\n  if (getDocumentElement(element) === rawOffsetParent) {\n    rawOffsetParent = rawOffsetParent.ownerDocument.body;\n  }\n  return rawOffsetParent;\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$1(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\nfunction rectsAreEqual(a, b) {\n  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\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 elementRectForRootMargin = element.getBoundingClientRect();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = elementRectForRootMargin;\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      if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {\n        // It's possible that even though the ratio is reported as 1, the\n        // element is not actually fully within the IntersectionObserver's root\n        // area anymore. This can happen under performance constraints. This may\n        // be a bug in the browser's IntersectionObserver implementation. To\n        // work around this, we compare the element's bounding rect now with\n        // what it was at the time we created the IntersectionObserver. If they\n        // are not equal then the element moved, so we refresh.\n        refresh();\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) : []), ...(floating ? 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 && floating) {\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    if (floating) {\n      resizeObserver.observe(floating);\n    }\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 && !rectsAreEqual(prevRefRect, nextRefRect)) {\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","// Modified from Grail UI v0.9.6 (2023-06-10)\n// Source: https://github.com/grail-ui/grail-ui\n// https://github.com/grail-ui/grail-ui/tree/master/packages/grail-ui/src/floating/placement.ts\nimport { flip, offset, arrow, shift, size, computePosition, autoUpdate, } from '@floating-ui/dom';\nimport { isHTMLElement, noop } from '../../helpers/index.js';\nconst defaultConfig = {\n    strategy: 'absolute',\n    placement: 'top',\n    gutter: 5,\n    flip: true,\n    sameWidth: false,\n    overflowPadding: 8,\n};\nconst ARROW_TRANSFORM = {\n    bottom: 'rotate(45deg)',\n    left: 'rotate(135deg)',\n    top: 'rotate(225deg)',\n    right: 'rotate(315deg)',\n};\nconst SIDE_OPTIONS = ['top', 'right', 'bottom', 'left'];\nconst ALIGN_OPTIONS = ['start', 'center', 'end'];\nexport function useFloating(reference, floating, opts = {}) {\n    if (!floating || !reference || opts === null)\n        return {\n            destroy: noop,\n        };\n    const options = { ...defaultConfig, ...opts };\n    const arrowEl = floating.querySelector('[data-arrow=true]');\n    const middleware = [];\n    if (options.flip) {\n        middleware.push(flip({\n            boundary: options.boundary,\n            padding: options.overflowPadding,\n        }));\n    }\n    const arrowOffset = isHTMLElement(arrowEl) ? arrowEl.offsetHeight / 2 : 0;\n    if (options.gutter || options.offset) {\n        const data = options.gutter ? { mainAxis: options.gutter } : options.offset;\n        if (data?.mainAxis != null) {\n            data.mainAxis += arrowOffset;\n        }\n        middleware.push(offset(data));\n    }\n    middleware.push(shift({\n        boundary: options.boundary,\n        crossAxis: options.overlap,\n        padding: options.overflowPadding,\n    }));\n    if (arrowEl) {\n        middleware.push(arrow({ element: arrowEl, padding: 8 }));\n    }\n    middleware.push(size({\n        padding: options.overflowPadding,\n        apply({ rects, availableHeight, availableWidth }) {\n            if (options.sameWidth) {\n                Object.assign(floating.style, {\n                    width: `${Math.round(rects.reference.width)}px`,\n                    minWidth: 'unset',\n                });\n            }\n            if (options.fitViewport) {\n                Object.assign(floating.style, {\n                    maxWidth: `${availableWidth}px`,\n                    maxHeight: `${availableHeight}px`,\n                });\n            }\n        },\n    }));\n    function compute() {\n        if (!reference || !floating)\n            return;\n        // if the reference is no longer in the document (e.g. it was removed), ignore it\n        if (isHTMLElement(reference) && !reference.ownerDocument.documentElement.contains(reference))\n            return;\n        const { placement, strategy } = options;\n        computePosition(reference, floating, {\n            placement,\n            middleware,\n            strategy,\n        }).then((data) => {\n            const x = Math.round(data.x);\n            const y = Math.round(data.y);\n            // get the chosen side and align from the placement to apply as attributes\n            // to the floating element and arrow\n            const [side, align] = getSideAndAlignFromPlacement(data.placement);\n            floating.setAttribute('data-side', side);\n            floating.setAttribute('data-align', align);\n            Object.assign(floating.style, {\n                position: options.strategy,\n                top: `${y}px`,\n                left: `${x}px`,\n            });\n            if (isHTMLElement(arrowEl) && data.middlewareData.arrow) {\n                const { x, y } = data.middlewareData.arrow;\n                const dir = data.placement.split('-')[0];\n                arrowEl.setAttribute('data-side', dir);\n                Object.assign(arrowEl.style, {\n                    position: 'absolute',\n                    left: x != null ? `${x}px` : '',\n                    top: y != null ? `${y}px` : '',\n                    [dir]: `calc(100% - ${arrowOffset}px)`,\n                    transform: ARROW_TRANSFORM[dir],\n                    backgroundColor: 'inherit',\n                    zIndex: 'inherit',\n                });\n            }\n            return data;\n        });\n    }\n    // Apply `position` to floating element prior to the computePosition() call.\n    Object.assign(floating.style, {\n        position: options.strategy,\n    });\n    return {\n        destroy: autoUpdate(reference, floating, compute),\n    };\n}\nfunction getSideAndAlignFromPlacement(placement) {\n    const [side, align = 'center'] = placement.split('-');\n    return [side, align];\n}\n","import { tick } from 'svelte';\nimport { isHTMLElement, noop } from '../helpers/index.js';\nexport const usePortal = ((el, target = 'body') => {\n    let targetEl;\n    if (!isHTMLElement(target) && typeof target !== 'string') {\n        return {\n            destroy: noop,\n        };\n    }\n    async function update(newTarget) {\n        target = newTarget;\n        if (typeof target === 'string') {\n            targetEl = document.querySelector(target);\n            if (targetEl === null) {\n                await tick();\n                targetEl = document.querySelector(target);\n            }\n            if (targetEl === null) {\n                throw new Error(`No element found matching css selector: \"${target}\"`);\n            }\n        }\n        else if (target instanceof HTMLElement) {\n            targetEl = target;\n        }\n        else {\n            throw new TypeError(`Unknown portal target type: ${target === null ? 'null' : typeof target}. Allowed types: string (CSS selector) or HTMLElement.`);\n        }\n        el.dataset.portal = '';\n        targetEl.appendChild(el);\n        el.hidden = false;\n    }\n    function destroy() {\n        el.remove();\n    }\n    update(target);\n    return {\n        update,\n        destroy,\n    };\n});\n","import { addEventListener, addMeltEventListener, makeElement, createElHelpers, effect, executeCallbacks, getPortalDestination, isBrowser, isDocument, isElement, isTouch, kbd, makeHullFromElements, noop, omit, overridable, pointInPolygon, styleToString, toWritableStores, removeUndefined, portalAttr, } from '../../internal/helpers/index.js';\nimport { useFloating, usePortal } from '../../internal/actions/index.js';\nimport { derived, writable } from 'svelte/store';\nimport { generateIds } from '../../internal/helpers/id.js';\nimport { tick } from 'svelte';\nconst defaults = {\n    positioning: {\n        placement: 'bottom',\n    },\n    arrowSize: 8,\n    defaultOpen: false,\n    closeOnPointerDown: true,\n    openDelay: 1000,\n    closeDelay: 0,\n    forceVisible: false,\n    portal: undefined,\n    closeOnEscape: true,\n    disableHoverableContent: false,\n    group: undefined,\n};\nconst { name } = createElHelpers('tooltip');\n// Store a global map to get the currently open tooltip.\nconst groupMap = new Map();\nexport const tooltipIdParts = ['trigger', 'content'];\nexport function createTooltip(props) {\n    const withDefaults = { ...defaults, ...props };\n    const options = toWritableStores(omit(withDefaults, 'open', 'ids'));\n    const { positioning, arrowSize, closeOnPointerDown, openDelay, closeDelay, forceVisible, portal, closeOnEscape, disableHoverableContent, group, } = options;\n    const openWritable = withDefaults.open ?? writable(withDefaults.defaultOpen);\n    const open = overridable(openWritable, withDefaults?.onOpenChange);\n    const openReason = writable(null);\n    const ids = toWritableStores({ ...generateIds(tooltipIdParts), ...withDefaults.ids });\n    let clickedTrigger = false;\n    const getEl = (part) => {\n        if (!isBrowser)\n            return null;\n        return document.getElementById(ids[part].get());\n    };\n    let openTimeout = null;\n    let closeTimeout = null;\n    function openTooltip(reason) {\n        if (closeTimeout) {\n            window.clearTimeout(closeTimeout);\n            closeTimeout = null;\n        }\n        if (!openTimeout) {\n            openTimeout = window.setTimeout(() => {\n                open.set(true);\n                // Don't override the reason if it's already set.\n                openReason.update((prev) => prev ?? reason);\n                openTimeout = null;\n            }, openDelay.get());\n        }\n    }\n    function closeTooltip(isBlur) {\n        if (openTimeout) {\n            window.clearTimeout(openTimeout);\n            openTimeout = null;\n        }\n        if (isBlur && isMouseInTooltipArea) {\n            // Normally when blurring the trigger, we want to close the tooltip.\n            // The exception is when the mouse is still in the tooltip area.\n            // In that case, we have to set the openReason to pointer, so that\n            // it can close when the mouse leaves the tooltip area.\n            openReason.set('pointer');\n            return;\n        }\n        if (!closeTimeout) {\n            closeTimeout = window.setTimeout(() => {\n                open.set(false);\n                openReason.set(null);\n                if (isBlur)\n                    clickedTrigger = false;\n                closeTimeout = null;\n            }, closeDelay.get());\n        }\n    }\n    const isVisible = derived([open, forceVisible], ([$open, $forceVisible]) => {\n        return $open || $forceVisible;\n    });\n    const trigger = makeElement(name('trigger'), {\n        stores: [ids.content, ids.trigger, open],\n        returned: ([$contentId, $triggerId, $open]) => {\n            return {\n                'aria-describedby': $contentId,\n                id: $triggerId,\n                'data-state': $open ? 'open' : 'closed',\n            };\n        },\n        action: (node) => {\n            const keydownHandler = (e) => {\n                if (closeOnEscape.get() && e.key === kbd.ESCAPE) {\n                    if (openTimeout) {\n                        window.clearTimeout(openTimeout);\n                        openTimeout = null;\n                    }\n                    open.set(false);\n                }\n            };\n            const unsub = executeCallbacks(addMeltEventListener(node, 'pointerdown', () => {\n                const $closeOnPointerDown = closeOnPointerDown.get();\n                if (!$closeOnPointerDown)\n                    return;\n                open.set(false);\n                clickedTrigger = true;\n                if (openTimeout) {\n                    window.clearTimeout(openTimeout);\n                    openTimeout = null;\n                }\n            }), addMeltEventListener(node, 'pointerenter', (e) => {\n                if (isTouch(e))\n                    return;\n                openTooltip('pointer');\n            }), addMeltEventListener(node, 'pointerleave', (e) => {\n                if (isTouch(e))\n                    return;\n                if (openTimeout) {\n                    window.clearTimeout(openTimeout);\n                    openTimeout = null;\n                }\n            }), addMeltEventListener(node, 'focus', () => {\n                if (clickedTrigger)\n                    return;\n                openTooltip('focus');\n            }), addMeltEventListener(node, 'blur', () => closeTooltip(true)), addMeltEventListener(node, 'keydown', keydownHandler), addEventListener(document, 'keydown', keydownHandler));\n            return {\n                destroy: unsub,\n            };\n        },\n    });\n    const content = makeElement(name('content'), {\n        stores: [isVisible, open, portal, ids.content],\n        returned: ([$isVisible, $open, $portal, $contentId]) => {\n            return removeUndefined({\n                role: 'tooltip',\n                hidden: $isVisible ? undefined : true,\n                tabindex: -1,\n                style: $isVisible ? undefined : styleToString({ display: 'none' }),\n                id: $contentId,\n                'data-portal': portalAttr($portal),\n                'data-state': $open ? 'open' : 'closed',\n            });\n        },\n        action: (node) => {\n            let unsubFloating = noop;\n            let unsubPortal = noop;\n            const unsubDerived = effect([isVisible, positioning, portal], ([$isVisible, $positioning, $portal]) => {\n                unsubPortal();\n                unsubFloating();\n                const triggerEl = getEl('trigger');\n                if (!$isVisible || !triggerEl)\n                    return;\n                tick().then(() => {\n                    unsubPortal();\n                    unsubFloating();\n                    const portalDest = getPortalDestination(node, $portal);\n                    if (portalDest)\n                        unsubPortal = usePortal(node, portalDest).destroy;\n                    unsubFloating = useFloating(triggerEl, node, $positioning).destroy;\n                });\n            });\n            /**\n             * We don't want the tooltip to remain open if the user starts scrolling\n             * while their pointer is over the tooltip, so we close it.\n             */\n            function handleScroll(e) {\n                if (!open.get())\n                    return;\n                const target = e.target;\n                if (!isElement(target) && !isDocument(target))\n                    return;\n                const triggerEl = getEl('trigger');\n                if (triggerEl && target.contains(triggerEl)) {\n                    closeTooltip();\n                }\n            }\n            const unsubEvents = executeCallbacks(addMeltEventListener(node, 'pointerenter', () => openTooltip('pointer')), addMeltEventListener(node, 'pointerdown', () => openTooltip('pointer')), addEventListener(window, 'scroll', handleScroll, { capture: true }));\n            return {\n                destroy() {\n                    unsubEvents();\n                    unsubPortal();\n                    unsubFloating();\n                    unsubDerived();\n                },\n            };\n        },\n    });\n    const arrow = makeElement(name('arrow'), {\n        stores: arrowSize,\n        returned: ($arrowSize) => ({\n            'data-arrow': true,\n            style: styleToString({\n                position: 'absolute',\n                width: `var(--arrow-size, ${$arrowSize}px)`,\n                height: `var(--arrow-size, ${$arrowSize}px)`,\n            }),\n        }),\n    });\n    let isMouseInTooltipArea = false;\n    effect(open, ($open) => {\n        const currentGroup = group.get();\n        if (currentGroup === undefined || currentGroup === false) {\n            return;\n        }\n        if (!$open) {\n            if (groupMap.get(currentGroup) === open) {\n                // Tooltip is no longer open\n                groupMap.delete(currentGroup);\n            }\n            return;\n        }\n        // Close the currently open tooltip in the same group\n        // and set this tooltip as the open one.\n        const currentOpen = groupMap.get(currentGroup);\n        currentOpen?.set(false);\n        groupMap.set(currentGroup, open);\n    });\n    effect([open, openReason], ([$open, $openReason]) => {\n        if (!$open || !isBrowser)\n            return;\n        return executeCallbacks(addEventListener(document, 'mousemove', (e) => {\n            const contentEl = getEl('content');\n            const triggerEl = getEl('trigger');\n            if (!contentEl || !triggerEl)\n                return;\n            const polygonElements = disableHoverableContent.get()\n                ? [triggerEl]\n                : [triggerEl, contentEl];\n            const polygon = makeHullFromElements(polygonElements);\n            isMouseInTooltipArea = pointInPolygon({\n                x: e.clientX,\n                y: e.clientY,\n            }, polygon);\n            if ($openReason !== 'pointer')\n                return;\n            if (!isMouseInTooltipArea) {\n                closeTooltip();\n            }\n        }));\n    });\n    return {\n        ids,\n        elements: {\n            trigger,\n            content,\n            arrow,\n        },\n        states: { open },\n        options,\n    };\n}\n","import { createEventDispatcher } from \"svelte\";\nexport function createDispatcher() {\n    const dispatch = createEventDispatcher();\n    return (e) => {\n        const { originalEvent } = e.detail;\n        const { cancelable } = e;\n        const type = originalEvent.type;\n        const shouldContinue = dispatch(type, { originalEvent, currentTarget: originalEvent.currentTarget }, { cancelable });\n        if (!shouldContinue) {\n            e.preventDefault();\n        }\n    };\n}\n","export function getPositioningUpdater(store) {\n    return (props = {}) => {\n        return updatePositioning(store, props);\n    };\n}\nexport function updatePositioning(store, props) {\n    const defaultPositioningProps = {\n        side: \"bottom\",\n        align: \"center\",\n        sideOffset: 0,\n        alignOffset: 0,\n        sameWidth: false,\n        avoidCollisions: true,\n        collisionPadding: 8,\n        fitViewport: false,\n        strategy: \"absolute\",\n        overlap: false,\n    };\n    const withDefaults = { ...defaultPositioningProps, ...props };\n    store.update((prev) => {\n        return {\n            ...prev,\n            placement: joinPlacement(withDefaults.side, withDefaults.align),\n            offset: {\n                ...prev.offset,\n                mainAxis: withDefaults.sideOffset,\n                crossAxis: withDefaults.alignOffset,\n            },\n            gutter: 0,\n            sameWidth: withDefaults.sameWidth,\n            flip: withDefaults.avoidCollisions,\n            overflowPadding: withDefaults.collisionPadding,\n            boundary: withDefaults.collisionBoundary,\n            fitViewport: withDefaults.fitViewport,\n            strategy: withDefaults.strategy,\n            overlap: withDefaults.overlap,\n        };\n    });\n}\nfunction joinPlacement(side, align) {\n    if (align === \"center\")\n        return side;\n    return `${side}-${align}`;\n}\n","import { createTooltip } from \"@melt-ui/svelte\";\nimport { getContext, setContext } from \"svelte\";\nimport { getPositioningUpdater } from \"../floating/helpers.js\";\nimport { createBitAttrs, getOptionUpdater, removeUndefined } from \"../../internal/index.js\";\nfunction getTooltipData() {\n    const NAME = \"tooltip\";\n    const PARTS = [\"arrow\", \"content\", \"trigger\"];\n    return {\n        NAME,\n        PARTS,\n    };\n}\nexport function setCtx(props) {\n    const { NAME, PARTS } = getTooltipData();\n    const getAttrs = createBitAttrs(NAME, PARTS);\n    const tooltip = {\n        ...createTooltip({\n            positioning: {\n                placement: \"top\",\n                gutter: 0,\n            },\n            openDelay: 700,\n            ...removeUndefined(props),\n            forceVisible: true,\n        }),\n        getAttrs,\n    };\n    setContext(NAME, tooltip);\n    return {\n        ...tooltip,\n        updateOption: getOptionUpdater(tooltip.options),\n    };\n}\nexport function getCtx() {\n    const { NAME } = getTooltipData();\n    return getContext(NAME);\n}\nexport function setArrow(size = 8) {\n    const tooltip = getCtx();\n    tooltip.options.arrowSize.set(size);\n    return tooltip;\n}\nexport function updatePositioning(props) {\n    const defaultPlacement = {\n        side: \"top\",\n        align: \"center\",\n        sideOffset: 1,\n    };\n    const withDefaults = { ...defaultPlacement, ...props };\n    const { options: { positioning }, } = getCtx();\n    const updater = getPositioningUpdater(positioning);\n    updater({ ...withDefaults });\n}\n","<script>import { derived } from \"svelte/store\";\nimport { setCtx } from \"../ctx.js\";\nexport let closeOnEscape = void 0;\nexport let portal = void 0;\nexport let closeOnPointerDown = void 0;\nexport let openDelay = void 0;\nexport let closeDelay = void 0;\nexport let open = void 0;\nexport let onOpenChange = void 0;\nexport let disableHoverableContent = void 0;\nexport let group = void 0;\nconst {\n  states: { open: localOpen },\n  updateOption,\n  ids\n} = setCtx({\n  closeOnEscape,\n  portal,\n  closeOnPointerDown,\n  openDelay,\n  closeDelay,\n  forceVisible: true,\n  defaultOpen: open,\n  disableHoverableContent,\n  group,\n  onOpenChange: ({ next }) => {\n    if (open !== next) {\n      onOpenChange?.(next);\n      open = next;\n    }\n    return next;\n  },\n  positioning: {\n    gutter: 0,\n    offset: {\n      mainAxis: 1\n    }\n  }\n});\nconst idValues = derived([ids.content, ids.trigger], ([$contentId, $triggerId]) => ({\n  content: $contentId,\n  trigger: $triggerId\n}));\n$: open !== void 0 && localOpen.set(open);\n$: updateOption(\"closeOnEscape\", closeOnEscape);\n$: updateOption(\"portal\", portal);\n$: updateOption(\"closeOnPointerDown\", closeOnPointerDown);\n$: updateOption(\"openDelay\", openDelay);\n$: updateOption(\"closeDelay\", closeDelay);\n$: updateOption(\"group\", group);\n$: updateOption(\"disableHoverableContent\", disableHoverableContent);\n</script>\n\n<slot ids={$idValues} />\n","<script>import { melt } from \"@melt-ui/svelte\";\nimport { getCtx, updatePositioning } from \"../ctx.js\";\nimport { createDispatcher } from \"../../../internal/index.js\";\nexport let transition = void 0;\nexport let transitionConfig = void 0;\nexport let inTransition = void 0;\nexport let inTransitionConfig = void 0;\nexport let outTransition = void 0;\nexport let outTransitionConfig = void 0;\nexport let asChild = false;\nexport let id = void 0;\nexport let side = \"top\";\nexport let align = \"center\";\nexport let sideOffset = 0;\nexport let alignOffset = 0;\nexport let collisionPadding = 8;\nexport let avoidCollisions = true;\nexport let collisionBoundary = void 0;\nexport let sameWidth = false;\nexport let fitViewport = false;\nexport let strategy = \"absolute\";\nexport let overlap = false;\nexport let el = void 0;\nconst {\n  elements: { content },\n  states: { open },\n  ids,\n  getAttrs\n} = getCtx();\nconst dispatch = createDispatcher();\nconst attrs = getAttrs(\"content\");\n$: if (id) {\n  ids.content.set(id);\n}\n$: builder = $content;\n$: Object.assign(builder, attrs);\n$: if ($open) {\n  updatePositioning({\n    side,\n    align,\n    sideOffset,\n    alignOffset,\n    collisionPadding,\n    avoidCollisions,\n    collisionBoundary,\n    sameWidth,\n    fitViewport,\n    strategy,\n    overlap\n  });\n}\n</script>\n\n{#if asChild && $open}\n\t<slot {builder} />\n{:else if transition && $open}\n\t<div\n\t\tbind:this={el}\n\t\t{...builder} use:builder.action\n\t\ttransition:transition={transitionConfig}\n\t\t{...$$restProps}\n\t\ton:m-pointerdown={dispatch}\n\t\ton:m-pointerenter={dispatch}\n\t>\n\t\t<slot {builder} />\n\t</div>\n{:else if inTransition && outTransition && $open}\n\t<div\n\t\tbind:this={el}\n\t\t{...builder} use:builder.action\n\t\tin:inTransition={inTransitionConfig}\n\t\tout:outTransition={outTransitionConfig}\n\t\t{...$$restProps}\n\t\ton:m-pointerdown={dispatch}\n\t\ton:m-pointerenter={dispatch}\n\t>\n\t\t<slot {builder} />\n\t</div>\n{:else if inTransition && $open}\n\t<div\n\t\tbind:this={el}\n\t\t{...builder} use:builder.action\n\t\tin:inTransition={inTransitionConfig}\n\t\t{...$$restProps}\n\t\ton:m-pointerdown={dispatch}\n\t\ton:m-pointerenter={dispatch}\n\t>\n\t\t<slot {builder} />\n\t</div>\n{:else if outTransition && $open}\n\t<div\n\t\tbind:this={el}\n\t\t{...builder} use:builder.action\n\t\tout:outTransition={outTransitionConfig}\n\t\t{...$$restProps}\n\t\ton:m-pointerdown={dispatch}\n\t\ton:m-pointerenter={dispatch}\n\t>\n\t\t<slot {builder} />\n\t</div>\n{:else if $open}\n\t<div\n\t\tbind:this={el}\n\t\t{...builder} use:builder.action\n\t\t{...$$restProps}\n\t\ton:m-pointerdown={dispatch}\n\t\ton:m-pointerenter={dispatch}\n\t>\n\t\t<slot {builder} />\n\t</div>\n{/if}\n","<script>import { melt } from \"@melt-ui/svelte\";\nimport { getCtx } from \"../ctx.js\";\nimport { createDispatcher } from \"../../../internal/index.js\";\nexport let asChild = false;\nexport let id = void 0;\nexport let el = void 0;\nconst {\n  elements: { trigger },\n  ids,\n  getAttrs\n} = getCtx();\nconst dispatch = createDispatcher();\nconst attrs = getAttrs(\"trigger\");\n$: if (id) {\n  ids.trigger.set(id);\n}\n$: builder = $trigger;\n$: Object.assign(builder, attrs);\n</script>\n\n{#if asChild}\n\t<slot {builder} />\n{:else}\n\t<button\n\t\tbind:this={el}\n\t\t{...builder} use:builder.action\n\t\ttype=\"button\"\n\t\t{...$$restProps}\n\t\ton:m-blur={dispatch}\n\t\ton:m-focus={dispatch}\n\t\ton:m-keydown={dispatch}\n\t\ton:m-pointerdown={dispatch}\n\t\ton:m-pointerenter={dispatch}\n\t\ton:m-pointerleave={dispatch}\n\t>\n\t\t<slot {builder} />\n\t</button>\n{/if}\n","<script lang=\"ts\">\n  import { Tooltip } from \"bits-ui\";\n  import { scale } from \"svelte/transition\";\n\n  export let disableHoverableContent = true;\n  export let tips: string;\n</script>\n\n<Tooltip.Root openDelay={400} closeDelay={0} {disableHoverableContent}>\n  <Tooltip.Trigger asChild let:builder>\n    <slot {builder} />\n  </Tooltip.Trigger>\n  <Tooltip.Content sideOffset={4} asChild let:builder>\n    <div transition:scale={{ start: 0.95, duration: 300 }} class=\"rounded bg-neutral-2/10 px-0.5em py-0.3em text-xs text-neutral-3 backdrop-blur-sm\" {...builder} use:builder.action>\n      {tips}\n    </div>\n  </Tooltip.Content>\n</Tooltip.Root>\n"],"names":["generateId","nanoid","generateIds","args","acc","curr","makeHull","points","newPoints","POINT_COMPARATOR","makeHullPresorted","upperHull","i","p","q","lowerHull","a","b","getPointsFromEl","el","rect","makeHullFromElements","els","pointInPolygon","point","polygon","inside","j","xi","yi","xj","yj","getPortalParent","node","parent","isHTMLElement","getPortalDestination","portalProp","min","max","round","floor","createCoords","v","oppositeSideMap","clamp","start","value","end","evaluate","param","getSide","placement","getAlignment","getOppositeAxis","axis","getAxisLength","getSideAxis","firstChar","getAlignmentAxis","getAlignmentSides","rects","rtl","alignment","alignmentAxis","length","mainAlignmentSide","getOppositePlacement","getExpandedPlacements","oppositePlacement","getOppositeAlignmentPlacement","lrPlacement","rlPlacement","tbPlacement","btPlacement","getSideList","side","isStart","getOppositeAxisPlacements","flipAlignment","direction","list","expandPaddingObject","padding","getPaddingObject","rectToClientRect","x","y","width","height","computeCoordsFromPlacement","_ref","reference","floating","sideAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","detectOverflow","state","options","_await$platform$isEle","platform","elements","strategy","boundary","rootBoundary","elementContext","altBoundary","paddingObject","element","clippingClientRect","offsetParent","offsetScale","elementClientRect","MAX_RESET_COUNT","computePosition","config","middleware","platformWithDetectOverflow","statefulPlacement","resetCount","middlewareData","currentMiddleware","name","fn","nextX","nextY","data","reset","arrow","arrowDimensions","isYAxis","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","offset","shouldAddOffset","alignmentOffset","flip","_middlewareData$arrow","_middlewareData$flip","initialPlacement","checkMainAxis","checkCrossAxis","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","detectOverflowOptions","initialSideAxis","isBasePlacement","fallbackPlacements","hasFallbackAxisSideDirection","placements","overflow","overflows","overflowsData","sides","_middlewareData$flip2","_overflowsData$filter","nextIndex","nextPlacement","d","resetPlacement","_overflowsData$filter2","currentSideAxis","originSides","convertValueToCoords","mainAxisMulti","crossAxisMulti","rawValue","mainAxis","crossAxis","_middlewareData$offse","diffCoords","shift","limiter","mainAxisCoord","crossAxisCoord","minSide","maxSide","limitedCoords","size","_state$middlewareData","_state$middlewareData2","apply","heightSide","widthSide","maximumClippingHeight","maximumClippingWidth","overflowAvailableHeight","overflowAvailableWidth","noShift","availableHeight","availableWidth","xMin","xMax","yMin","yMax","nextDimensions","hasWindow","getNodeName","isNode","getWindow","_node$ownerDocument","getDocumentElement","isElement","isShadowRoot","isOverflowElement","overflowX","overflowY","display","getComputedStyle","isTableElement","isTopLayer","willChangeRe","containRe","isNotNone","isWebKitValue","isContainingBlock","elementOrCss","css","isWebKit","getContainingBlock","currentNode","getParentNode","isLastTraversableNode","getNodeScroll","result","getNearestOverflowAncestor","parentNode","getOverflowAncestors","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","win","frameElement","getFrameElement","getCssDimensions","getComputedStyle$1","hasOffset","offsetWidth","offsetHeight","shouldFallback","unwrapElement","getScale","domElement","$","noOffsets","getVisualOffsets","shouldAddVisualOffsets","isFixed","floatingOffsetParent","getBoundingClientRect","includeScale","isFixedStrategy","clientRect","scale","visualOffsets","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","left","top","getWindowScrollBarX","leftScroll","getHTMLOffset","documentElement","scroll","htmlRect","convertOffsetParentRelativeRectToViewportRelativeRect","topLayer","offsets","isOffsetParentAnElement","offsetRect","htmlOffset","getClientRects","getDocumentRect","html","body","SCROLLBAR_MAX","getViewportRect","visualViewport","visualViewportBased","windowScrollbarX","doc","bodyStyles","bodyMarginInline","clippingStableScrollbarWidth","getInnerBoundingClientRect","getClientRectFromClippingAncestor","clippingAncestor","hasFixedPositionAncestor","stopNode","getClippingElementAncestors","cache","cachedResult","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","ancestor","getClippingRect","clippingAncestors","firstRect","right","bottom","getDimensions","getRectRelativeToOffsetParent","setLeftRTLScrollbarOffset","isStaticPositioned","getTrueOffsetParent","polyfill","rawOffsetParent","getOffsetParent","svgOffsetParent","getElementRects","getOffsetParentFn","getDimensionsFn","floatingDimensions","isRTL","rectsAreEqual","observeMove","onMove","io","timeoutId","root","cleanup","_io","refresh","skip","threshold","elementRectForRootMargin","insetTop","insetRight","insetBottom","insetLeft","isFirstUpdate","handleObserve","entries","ratio","autoUpdate","update","ancestorScroll","ancestorResize","elementResize","layoutShift","animationFrame","referenceEl","ancestors","cleanupIo","reobserveFrame","resizeObserver","firstEntry","_resizeObserver","frameId","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","offset$1","shift$1","flip$1","size$1","arrow$1","mergedOptions","platformWithCache","computePosition$1","defaultConfig","ARROW_TRANSFORM","useFloating","opts","noop","arrowEl","arrowOffset","compute","align","getSideAndAlignFromPlacement","dir","usePortal","target","targetEl","newTarget","tick","destroy","defaults","createElHelpers","groupMap","tooltipIdParts","createTooltip","props","withDefaults","toWritableStores","omit","positioning","arrowSize","closeOnPointerDown","openDelay","closeDelay","forceVisible","portal","closeOnEscape","disableHoverableContent","group","openWritable","writable","open","overridable","openReason","ids","clickedTrigger","getEl","part","isBrowser","openTimeout","closeTimeout","openTooltip","reason","prev","closeTooltip","isBlur","isMouseInTooltipArea","isVisible","derived","$open","$forceVisible","trigger","makeElement","$contentId","$triggerId","keydownHandler","e","kbd","executeCallbacks","addMeltEventListener","isTouch","addEventListener","content","$isVisible","$portal","removeUndefined","styleToString","portalAttr","unsubFloating","unsubPortal","unsubDerived","effect","$positioning","triggerEl","portalDest","handleScroll","isDocument","unsubEvents","$arrowSize","currentGroup","currentOpen","$openReason","contentEl","polygonElements","createDispatcher","dispatch","createEventDispatcher","originalEvent","cancelable","type","getPositioningUpdater","store","updatePositioning","joinPlacement","getTooltipData","setCtx","NAME","PARTS","getAttrs","createBitAttrs","tooltip","setContext","getOptionUpdater","getCtx","getContext","ctx","$$props","onOpenChange","localOpen","updateOption","next","$$invalidate","idValues","div_levels","insert_hydration","div","anchor","transition","transitionConfig","inTransition","inTransitionConfig","outTransition","outTransitionConfig","asChild","id","sideOffset","alignOffset","collisionPadding","avoidCollisions","collisionBoundary","sameWidth","fitViewport","overlap","attrs","$$value","builder","$content","button_levels","button","$trigger","div_data","div_transition","create_bidirectional_transition","tips"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]}