{"version":3,"file":"9088.9dd1fad9.js","mappings":"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","sources":["webpack://@finviz/website/../node_modules/body-scroll-lock/lib/bodyScrollLock.esm.js","webpack://@finviz/website/../node_modules/lodash.debounce/index.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/MFZZDIHG.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/3OMHZVJD.js","webpack://@finviz/website/../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","webpack://@finviz/website/../node_modules/@floating-ui/core/dist/floating-ui.core.mjs","webpack://@finviz/website/../node_modules/@floating-ui/utils/dom/dist/floating-ui.utils.dom.mjs","webpack://@finviz/website/../node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/BYD75WXE.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/TE637IA7.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/TWDHCE7Y.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/E5E7G32I.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/tooltip/tooltip-store.js","webpack://@finviz/website/../node_modules/@ariakit/core/esm/__chunks/BRS7GKWU.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/WKII7I2E.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/XWCFCD3Q.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/FWINX72I.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/tooltip/tooltip-anchor.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/QFL5V2DO.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/UFM3D5TN.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/tooltip/tooltip-arrow.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/YMV43K4F.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/6YZEXKNV.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/tooltip/tooltip.js"],"sourcesContent":["function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\n// Older browsers don't support event options, feature detect it.\n\n// Adopted and modified solution from Bohdan Didukh (2017)\n// https://stackoverflow.com/questions/41594997/ios-10-safari-prevent-scrolling-behind-a-fixed-overlay-and-maintain-scroll-posi\n\nvar hasPassiveEvents = false;\nif (typeof window !== 'undefined') {\n  var passiveTestOptions = {\n    get passive() {\n      hasPassiveEvents = true;\n      return undefined;\n    }\n  };\n  window.addEventListener('testPassive', null, passiveTestOptions);\n  window.removeEventListener('testPassive', null, passiveTestOptions);\n}\n\nvar isIosDevice = typeof window !== 'undefined' && window.navigator && window.navigator.platform && (/iP(ad|hone|od)/.test(window.navigator.platform) || window.navigator.platform === 'MacIntel' && window.navigator.maxTouchPoints > 1);\n\n\nvar locks = [];\nvar documentListenerAdded = false;\nvar initialClientY = -1;\nvar previousBodyOverflowSetting = void 0;\nvar previousBodyPaddingRight = void 0;\n\n// returns true if `el` should be allowed to receive touchmove events.\nvar allowTouchMove = function allowTouchMove(el) {\n  return locks.some(function (lock) {\n    if (lock.options.allowTouchMove && lock.options.allowTouchMove(el)) {\n      return true;\n    }\n\n    return false;\n  });\n};\n\nvar preventDefault = function preventDefault(rawEvent) {\n  var e = rawEvent || window.event;\n\n  // For the case whereby consumers adds a touchmove event listener to document.\n  // Recall that we do document.addEventListener('touchmove', preventDefault, { passive: false })\n  // in disableBodyScroll - so if we provide this opportunity to allowTouchMove, then\n  // the touchmove event on document will break.\n  if (allowTouchMove(e.target)) {\n    return true;\n  }\n\n  // Do not prevent if the event has more than one touch (usually meaning this is a multi touch gesture like pinch to zoom).\n  if (e.touches.length > 1) return true;\n\n  if (e.preventDefault) e.preventDefault();\n\n  return false;\n};\n\nvar setOverflowHidden = function setOverflowHidden(options) {\n  // If previousBodyPaddingRight is already set, don't set it again.\n  if (previousBodyPaddingRight === undefined) {\n    var _reserveScrollBarGap = !!options && options.reserveScrollBarGap === true;\n    var scrollBarGap = window.innerWidth - document.documentElement.clientWidth;\n\n    if (_reserveScrollBarGap && scrollBarGap > 0) {\n      previousBodyPaddingRight = document.body.style.paddingRight;\n      document.body.style.paddingRight = scrollBarGap + 'px';\n    }\n  }\n\n  // If previousBodyOverflowSetting is already set, don't set it again.\n  if (previousBodyOverflowSetting === undefined) {\n    previousBodyOverflowSetting = document.body.style.overflow;\n    document.body.style.overflow = 'hidden';\n  }\n};\n\nvar restoreOverflowSetting = function restoreOverflowSetting() {\n  if (previousBodyPaddingRight !== undefined) {\n    document.body.style.paddingRight = previousBodyPaddingRight;\n\n    // Restore previousBodyPaddingRight to undefined so setOverflowHidden knows it\n    // can be set again.\n    previousBodyPaddingRight = undefined;\n  }\n\n  if (previousBodyOverflowSetting !== undefined) {\n    document.body.style.overflow = previousBodyOverflowSetting;\n\n    // Restore previousBodyOverflowSetting to undefined\n    // so setOverflowHidden knows it can be set again.\n    previousBodyOverflowSetting = undefined;\n  }\n};\n\n// https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#Problems_and_solutions\nvar isTargetElementTotallyScrolled = function isTargetElementTotallyScrolled(targetElement) {\n  return targetElement ? targetElement.scrollHeight - targetElement.scrollTop <= targetElement.clientHeight : false;\n};\n\nvar handleScroll = function handleScroll(event, targetElement) {\n  var clientY = event.targetTouches[0].clientY - initialClientY;\n\n  if (allowTouchMove(event.target)) {\n    return false;\n  }\n\n  if (targetElement && targetElement.scrollTop === 0 && clientY > 0) {\n    // element is at the top of its scroll.\n    return preventDefault(event);\n  }\n\n  if (isTargetElementTotallyScrolled(targetElement) && clientY < 0) {\n    // element is at the bottom of its scroll.\n    return preventDefault(event);\n  }\n\n  event.stopPropagation();\n  return true;\n};\n\nexport var disableBodyScroll = function disableBodyScroll(targetElement, options) {\n  // targetElement must be provided\n  if (!targetElement) {\n    // eslint-disable-next-line no-console\n    console.error('disableBodyScroll unsuccessful - targetElement must be provided when calling disableBodyScroll on IOS devices.');\n    return;\n  }\n\n  // disableBodyScroll must not have been called on this targetElement before\n  if (locks.some(function (lock) {\n    return lock.targetElement === targetElement;\n  })) {\n    return;\n  }\n\n  var lock = {\n    targetElement: targetElement,\n    options: options || {}\n  };\n\n  locks = [].concat(_toConsumableArray(locks), [lock]);\n\n  if (isIosDevice) {\n    targetElement.ontouchstart = function (event) {\n      if (event.targetTouches.length === 1) {\n        // detect single touch.\n        initialClientY = event.targetTouches[0].clientY;\n      }\n    };\n    targetElement.ontouchmove = function (event) {\n      if (event.targetTouches.length === 1) {\n        // detect single touch.\n        handleScroll(event, targetElement);\n      }\n    };\n\n    if (!documentListenerAdded) {\n      document.addEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = true;\n    }\n  } else {\n    setOverflowHidden(options);\n  }\n};\n\nexport var clearAllBodyScrollLocks = function clearAllBodyScrollLocks() {\n  if (isIosDevice) {\n    // Clear all locks ontouchstart/ontouchmove handlers, and the references.\n    locks.forEach(function (lock) {\n      lock.targetElement.ontouchstart = null;\n      lock.targetElement.ontouchmove = null;\n    });\n\n    if (documentListenerAdded) {\n      document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = false;\n    }\n\n    // Reset initial clientY.\n    initialClientY = -1;\n  } else {\n    restoreOverflowSetting();\n  }\n\n  locks = [];\n};\n\nexport var enableBodyScroll = function enableBodyScroll(targetElement) {\n  if (!targetElement) {\n    // eslint-disable-next-line no-console\n    console.error('enableBodyScroll unsuccessful - targetElement must be provided when calling enableBodyScroll on IOS devices.');\n    return;\n  }\n\n  locks = locks.filter(function (lock) {\n    return lock.targetElement !== targetElement;\n  });\n\n  if (isIosDevice) {\n    targetElement.ontouchstart = null;\n    targetElement.ontouchmove = null;\n\n    if (documentListenerAdded && locks.length === 0) {\n      document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = false;\n    }\n  } else if (!locks.length) {\n    restoreOverflowSetting();\n  }\n};\n\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = debounce;\n","\"use client\";\nimport {\n  createDialogStore\n} from \"./5RJNXXU2.js\";\nimport {\n  createStore,\n  mergeStore,\n  omit,\n  throwOnConflictingProps\n} from \"./R676XYVY.js\";\nimport {\n  defaultValue\n} from \"./22HHDS5F.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/popover/popover-store.ts\nfunction createPopoverStore(_a = {}) {\n  var _b = _a, {\n    popover: otherPopover\n  } = _b, props = __objRest(_b, [\n    \"popover\"\n  ]);\n  const store = mergeStore(\n    props.store,\n    omit(otherPopover, [\n      \"arrowElement\",\n      \"anchorElement\",\n      \"contentElement\",\n      \"popoverElement\",\n      \"disclosureElement\"\n    ])\n  );\n  throwOnConflictingProps(props, store);\n  const syncState = store == null ? void 0 : store.getState();\n  const dialog = createDialogStore(__spreadProps(__spreadValues({}, props), { store }));\n  const placement = defaultValue(\n    props.placement,\n    syncState == null ? void 0 : syncState.placement,\n    \"bottom\"\n  );\n  const initialState = __spreadProps(__spreadValues({}, dialog.getState()), {\n    placement,\n    currentPlacement: placement,\n    anchorElement: defaultValue(syncState == null ? void 0 : syncState.anchorElement, null),\n    popoverElement: defaultValue(syncState == null ? void 0 : syncState.popoverElement, null),\n    arrowElement: defaultValue(syncState == null ? void 0 : syncState.arrowElement, null),\n    rendered: Symbol(\"rendered\")\n  });\n  const popover = createStore(initialState, dialog, store);\n  return __spreadProps(__spreadValues(__spreadValues({}, dialog), popover), {\n    setAnchorElement: (element) => popover.setState(\"anchorElement\", element),\n    setPopoverElement: (element) => popover.setState(\"popoverElement\", element),\n    setArrowElement: (element) => popover.setState(\"arrowElement\", element),\n    render: () => popover.setState(\"rendered\", Symbol(\"rendered\"))\n  });\n}\n\nexport {\n  createPopoverStore\n};\n","\"use client\";\nimport {\n  HovercardContextProvider,\n  HovercardScopedContextProvider\n} from \"./TWDHCE7Y.js\";\nimport {\n  createStoreContext\n} from \"./5M6RSQEC.js\";\n\n// src/tooltip/tooltip-context.tsx\nvar ctx = createStoreContext(\n  [HovercardContextProvider],\n  [HovercardScopedContextProvider]\n);\nvar useTooltipContext = ctx.useContext;\nvar useTooltipScopedContext = ctx.useScopedContext;\nvar useTooltipProviderContext = ctx.useProviderContext;\nvar TooltipContextProvider = ctx.ContextProvider;\nvar TooltipScopedContextProvider = ctx.ScopedContextProvider;\n\nexport {\n  useTooltipContext,\n  useTooltipScopedContext,\n  useTooltipProviderContext,\n  TooltipContextProvider,\n  TooltipScopedContextProvider\n};\n","const sides = ['top', 'right', 'bottom', 'left'];\nconst alignments = ['start', 'end'];\nconst placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-\" + alignments[0], side + \"-\" + alignments[1]), []);\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  return {\n    ...rect,\n    top: rect.y,\n    left: rect.x,\n    right: rect.x + rect.width,\n    bottom: rect.y + rect.height\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n","import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a reference element when it is given a certain positioning strategy.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n      continue;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    ...rects.floating,\n    x,\n    y\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    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center != offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const 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      if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle.\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$map$so;\n                const placement = (_overflowsData$map$so = overflowsData.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$map$so[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n// For type backwards-compatibility, the `OffsetOptions` type was also\n// Derivable.\nasync function convertValueToCoords(state, options) {\n  const {\n    placement,\n    platform,\n    elements\n  } = state;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getSideAxis(placement) === 'y';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: 0,\n    crossAxis: 0,\n    alignmentAxis: null,\n    ...rawValue\n  };\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = function (options) {\n  if (options === void 0) {\n    options = 0;\n  }\n  return {\n    name: 'offset',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y\n      } = state;\n      const diffCoords = await convertValueToCoords(state, options);\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: diffCoords\n      };\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'shift',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y,\n        placement\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const crossAxis = getSideAxis(getSide(placement));\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = clamp(min, mainAxisCoord, max);\n      }\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = clamp(min, crossAxisCoord, max);\n      }\n      const limitedCoords = limiter.fn({\n        ...state,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return {\n        ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y\n        }\n      };\n    }\n  };\n};\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    options,\n    fn(state) {\n      const {\n        x,\n        y,\n        placement,\n        rects,\n        middlewareData\n      } = state;\n      const {\n        offset = 0,\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const crossAxis = getSideAxis(placement);\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      const rawOffset = evaluate(offset, state);\n      const computedOffset = typeof rawOffset === 'number' ? {\n        mainAxis: rawOffset,\n        crossAxis: 0\n      } : {\n        mainAxis: 0,\n        crossAxis: 0,\n        ...rawOffset\n      };\n      if (checkMainAxis) {\n        const len = mainAxis === 'y' ? 'height' : 'width';\n        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;\n        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;\n        if (mainAxisCoord < limitMin) {\n          mainAxisCoord = limitMin;\n        } else if (mainAxisCoord > limitMax) {\n          mainAxisCoord = limitMax;\n        }\n      }\n      if (checkCrossAxis) {\n        var _middlewareData$offse, _middlewareData$offse2;\n        const len = mainAxis === 'y' ? 'width' : 'height';\n        const isOriginSide = ['top', 'left'].includes(getSide(placement));\n        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);\n        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);\n        if (crossAxisCoord < limitMin) {\n          crossAxisCoord = limitMin;\n        } else if (crossAxisCoord > limitMax) {\n          crossAxisCoord = limitMax;\n        }\n      }\n      return {\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      };\n    }\n  };\n};\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'size',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const overflowAvailableHeight = height - overflow[heightSide];\n      const overflowAvailableWidth = width - overflow[widthSide];\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if (isYAxis) {\n        const maximumClippingWidth = width - overflow.left - overflow.right;\n        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;\n      } else {\n        const maximumClippingHeight = height - overflow.top - overflow.bottom;\n        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;\n      }\n      if (noShift && !alignment) {\n        const xMin = max(overflow.left, 0);\n        const xMax = max(overflow.right, 0);\n        const yMin = max(overflow.top, 0);\n        const yMax = max(overflow.bottom, 0);\n        if (isYAxis) {\n          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));\n        } else {\n          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));\n        }\n      }\n      await apply({\n        ...state,\n        availableWidth,\n        availableHeight\n      });\n      const nextDimensions = await platform.getDimensions(elements.floating);\n      if (width !== nextDimensions.width || height !== nextDimensions.height) {\n        return {\n          reset: {\n            rects: true\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nexport { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, shift, size };\n","function getNodeName(node) {\n  if (isNode(node)) {\n    return (node.nodeName || '').toLowerCase();\n  }\n  // Mocked nodes in testing environments may not be instances of Node. By\n  // returning `#document` an infinite loop won't occur.\n  // https://github.com/floating-ui/floating-ui/issues/2317\n  return '#document';\n}\nfunction getWindow(node) {\n  var _node$ownerDocument;\n  return (node == null ? void 0 : (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\nfunction getDocumentElement(node) {\n  var _ref;\n  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;\n}\nfunction isNode(value) {\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  // Browsers without `ShadowRoot` support.\n  if (typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle(element);\n  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isContainingBlock(element) {\n  const webkit = isWebKit();\n  const css = getComputedStyle(element);\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else {\n      currentNode = getParentNode(currentNode);\n    }\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.pageXOffset,\n    scrollTop: element.pageYOffset\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    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isWebKit };\n","import { rectToClientRect, computePosition as computePosition$1 } from '@floating-ui/core';\nexport { arrow, autoPlacement, detectOverflow, flip, hide, inline, limitShift, offset, shift, size } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getDocumentElement, getNodeName, isOverflowElement, getNodeScroll, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';\nexport { getOverflowAncestors } from '@floating-ui/utils/dom';\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createCoords(0);\nfunction getVisualOffsets(element) {\n  const win = getWindow(element);\n  if (!isWebKit() || !win.visualViewport) {\n    return noOffsets;\n  }\n  return {\n    x: win.visualViewport.offsetLeft,\n    y: win.visualViewport.offsetTop\n  };\n}\nfunction shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {\n    return false;\n  }\n  return isFixed;\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentIFrame = win.frameElement;\n    while (currentIFrame && offsetParent && offsetWin !== win) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentIFrame = getWindow(currentIFrame).frameElement;\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  if (offsetParent === documentElement) {\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  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent);\n      scale = getScale(offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    }\n  }\n  return {\n    width: rect.width * scale.x,\n    height: rect.height * scale.y,\n    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\n}\n\nfunction getWindowScrollBarX(element) {\n  // If <html> has a CSS width greater than the viewport, then this will be\n  // incorrect for RTL.\n  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;\n}\n\n// Gets the entire size of the scrollable document area, even extending outside\n// of the `<html>` and `<body>` rect bounds if horizontally scrollable.\nfunction getDocumentRect(element) {\n  const html = getDocumentElement(element);\n  const scroll = getNodeScroll(element);\n  const body = element.ownerDocument.body;\n  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);\n  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);\n  let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n  const y = -scroll.scrollTop;\n  if (getComputedStyle(body).direction === 'rtl') {\n    x += max(html.clientWidth, body.clientWidth) - width;\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\nfunction getViewportRect(element, strategy) {\n  const win = getWindow(element);\n  const html = getDocumentElement(element);\n  const visualViewport = win.visualViewport;\n  let width = html.clientWidth;\n  let height = html.clientHeight;\n  let x = 0;\n  let y = 0;\n  if (visualViewport) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n    const visualViewportBased = isWebKit();\n    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {\n      x = visualViewport.offsetLeft;\n      y = visualViewport.offsetTop;\n    }\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\n// Returns the inner client rect, subtracting scrollbars if present.\nfunction getInnerBoundingClientRect(element, strategy) {\n  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');\n  const top = clientRect.top + element.clientTop;\n  const left = clientRect.left + element.clientLeft;\n  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);\n  const width = element.clientWidth * scale.x;\n  const height = element.clientHeight * scale.y;\n  const x = left * scale.x;\n  const y = top * scale.y;\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\nfunction getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {\n  let rect;\n  if (clippingAncestor === 'viewport') {\n    rect = getViewportRect(element, strategy);\n  } else if (clippingAncestor === 'document') {\n    rect = getDocumentRect(getDocumentElement(element));\n  } else if (isElement(clippingAncestor)) {\n    rect = getInnerBoundingClientRect(clippingAncestor, strategy);\n  } else {\n    const visualOffsets = getVisualOffsets(element);\n    rect = {\n      ...clippingAncestor,\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y\n    };\n  }\n  return rectToClientRect(rect);\n}\nfunction hasFixedPositionAncestor(element, stopNode) {\n  const parentNode = getParentNode(element);\n  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {\n    return false;\n  }\n  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);\n}\n\n// A \"clipping ancestor\" is an `overflow` element with the characteristic of\n// clipping (or hiding) child elements. This returns all clipping ancestors\n// of the given element up the tree.\nfunction getClippingElementAncestors(element, cache) {\n  const cachedResult = cache.get(element);\n  if (cachedResult) {\n    return cachedResult;\n  }\n  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');\n  let currentContainingBlockComputedStyle = null;\n  const elementIsFixed = getComputedStyle(element).position === 'fixed';\n  let currentNode = elementIsFixed ? getParentNode(element) : element;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    const computedStyle = getComputedStyle(currentNode);\n    const currentNodeIsContaining = isContainingBlock(currentNode);\n    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {\n      currentContainingBlockComputedStyle = null;\n    }\n    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);\n    if (shouldDropCurrentNode) {\n      // Drop non-containing blocks.\n      result = result.filter(ancestor => ancestor !== currentNode);\n    } else {\n      // Record last containing block for next iteration.\n      currentContainingBlockComputedStyle = computedStyle;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  cache.set(element, result);\n  return result;\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors.\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const elementClippingAncestors = boundary === 'clippingAncestors' ? getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  return getCssDimensions(element);\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isOffsetParentAnElement) {\n      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n  return {\n    x: rect.left + scroll.scrollLeft - offsets.x,\n    y: rect.top + scroll.scrollTop - offsets.y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  return element.offsetParent;\n}\n\n// Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\nfunction getOffsetParent(element, polyfill) {\n  const window = getWindow(element);\n  if (!isHTMLElement(element)) {\n    return window;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {\n    return window;\n  }\n  return offsetParent || getContainingBlock(element) || window;\n}\n\nconst getElementRects = async function (_ref) {\n  let {\n    reference,\n    floating,\n    strategy\n  } = _ref;\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  return {\n    reference: getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      ...(await getDimensionsFn(floating))\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    clearTimeout(timeoutId);\n    io && io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = element.getBoundingClientRect();\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 100);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          resizeObserver && resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo && cleanupIo();\n    resizeObserver && resizeObserver.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a reference element when it is given a certain CSS positioning\n * strategy.\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 { autoUpdate, computePosition, platform };\n","\"use client\";\nimport {\n  createDialogComponent,\n  useDialog\n} from \"./KXSO5EFT.js\";\nimport {\n  PopoverScopedContextProvider,\n  usePopoverProviderContext\n} from \"./TE637IA7.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./5M6RSQEC.js\";\nimport {\n  useEvent,\n  usePortalRef,\n  useSafeLayoutEffect,\n  useWrapElement\n} from \"./6O5OEQGF.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/popover/popover.tsx\nimport { useState } from \"react\";\nimport { invariant } from \"@ariakit/core/utils/misc\";\nimport {\n  arrow,\n  autoUpdate,\n  computePosition,\n  flip,\n  limitShift,\n  offset,\n  shift,\n  size\n} from \"@floating-ui/dom\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nfunction createDOMRect(x = 0, y = 0, width = 0, height = 0) {\n  if (typeof DOMRect === \"function\") {\n    return new DOMRect(x, y, width, height);\n  }\n  const rect = {\n    x,\n    y,\n    width,\n    height,\n    top: y,\n    right: x + width,\n    bottom: y + height,\n    left: x\n  };\n  return __spreadProps(__spreadValues({}, rect), { toJSON: () => rect });\n}\nfunction getDOMRect(anchorRect) {\n  if (!anchorRect)\n    return createDOMRect();\n  const { x, y, width, height } = anchorRect;\n  return createDOMRect(x, y, width, height);\n}\nfunction getAnchorElement(anchorElement, getAnchorRect) {\n  const contextElement = anchorElement || void 0;\n  return {\n    contextElement,\n    getBoundingClientRect: () => {\n      const anchor = anchorElement;\n      const anchorRect = getAnchorRect == null ? void 0 : getAnchorRect(anchor);\n      if (anchorRect || !anchor) {\n        return getDOMRect(anchorRect);\n      }\n      return anchor.getBoundingClientRect();\n    }\n  };\n}\nfunction isValidPlacement(flip2) {\n  return /^(?:top|bottom|left|right)(?:-(?:start|end))?$/.test(flip2);\n}\nfunction roundByDPR(value) {\n  const dpr = window.devicePixelRatio || 1;\n  return Math.round(value * dpr) / dpr;\n}\nfunction getOffsetMiddleware(arrowElement, props) {\n  return offset(({ placement }) => {\n    var _a;\n    const arrowOffset = ((arrowElement == null ? void 0 : arrowElement.clientHeight) || 0) / 2;\n    const finalGutter = typeof props.gutter === \"number\" ? props.gutter + arrowOffset : (_a = props.gutter) != null ? _a : arrowOffset;\n    const hasAlignment = !!placement.split(\"-\")[1];\n    return {\n      crossAxis: !hasAlignment ? props.shift : void 0,\n      mainAxis: finalGutter,\n      alignmentAxis: props.shift\n    };\n  });\n}\nfunction getFlipMiddleware(props) {\n  if (props.flip === false)\n    return;\n  const fallbackPlacements = typeof props.flip === \"string\" ? props.flip.split(\" \") : void 0;\n  invariant(\n    !fallbackPlacements || fallbackPlacements.every(isValidPlacement),\n    process.env.NODE_ENV !== \"production\" && \"`flip` expects a spaced-delimited list of placements\"\n  );\n  return flip({\n    padding: props.overflowPadding,\n    fallbackPlacements\n  });\n}\nfunction getShiftMiddleware(props) {\n  if (!props.slide && !props.overlap)\n    return;\n  return shift({\n    mainAxis: props.slide,\n    crossAxis: props.overlap,\n    padding: props.overflowPadding,\n    limiter: limitShift()\n  });\n}\nfunction getSizeMiddleware(props) {\n  return size({\n    padding: props.overflowPadding,\n    apply({ elements, availableWidth, availableHeight, rects }) {\n      const wrapper = elements.floating;\n      const referenceWidth = Math.round(rects.reference.width);\n      availableWidth = Math.floor(availableWidth);\n      availableHeight = Math.floor(availableHeight);\n      wrapper.style.setProperty(\n        \"--popover-anchor-width\",\n        `${referenceWidth}px`\n      );\n      wrapper.style.setProperty(\n        \"--popover-available-width\",\n        `${availableWidth}px`\n      );\n      wrapper.style.setProperty(\n        \"--popover-available-height\",\n        `${availableHeight}px`\n      );\n      if (props.sameWidth) {\n        wrapper.style.width = `${referenceWidth}px`;\n      }\n      if (props.fitViewport) {\n        wrapper.style.maxWidth = `${availableWidth}px`;\n        wrapper.style.maxHeight = `${availableHeight}px`;\n      }\n    }\n  });\n}\nfunction getArrowMiddleware(arrowElement, props) {\n  if (!arrowElement)\n    return;\n  return arrow({\n    element: arrowElement,\n    padding: props.arrowPadding\n  });\n}\nvar usePopover = createHook(\n  function usePopover2(_a) {\n    var _b = _a, {\n      store,\n      modal = false,\n      portal = !!modal,\n      preserveTabOrder = true,\n      autoFocusOnShow = true,\n      wrapperProps,\n      fixed = false,\n      flip: flip2 = true,\n      shift: shift2 = 0,\n      slide = true,\n      overlap = false,\n      sameWidth = false,\n      fitViewport = false,\n      gutter,\n      arrowPadding = 4,\n      overflowPadding = 8,\n      getAnchorRect,\n      updatePosition\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"modal\",\n      \"portal\",\n      \"preserveTabOrder\",\n      \"autoFocusOnShow\",\n      \"wrapperProps\",\n      \"fixed\",\n      \"flip\",\n      \"shift\",\n      \"slide\",\n      \"overlap\",\n      \"sameWidth\",\n      \"fitViewport\",\n      \"gutter\",\n      \"arrowPadding\",\n      \"overflowPadding\",\n      \"getAnchorRect\",\n      \"updatePosition\"\n    ]);\n    const context = usePopoverProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"Popover must receive a `store` prop or be wrapped in a PopoverProvider component.\"\n    );\n    const arrowElement = store.useState(\"arrowElement\");\n    const anchorElement = store.useState(\"anchorElement\");\n    const disclosureElement = store.useState(\"disclosureElement\");\n    const popoverElement = store.useState(\"popoverElement\");\n    const contentElement = store.useState(\"contentElement\");\n    const placement = store.useState(\"placement\");\n    const mounted = store.useState(\"mounted\");\n    const rendered = store.useState(\"rendered\");\n    const [positioned, setPositioned] = useState(false);\n    const { portalRef, domReady } = usePortalRef(portal, props.portalRef);\n    const getAnchorRectProp = useEvent(getAnchorRect);\n    const updatePositionProp = useEvent(updatePosition);\n    const hasCustomUpdatePosition = !!updatePosition;\n    useSafeLayoutEffect(() => {\n      if (!(popoverElement == null ? void 0 : popoverElement.isConnected))\n        return;\n      popoverElement.style.setProperty(\n        \"--popover-overflow-padding\",\n        `${overflowPadding}px`\n      );\n      const anchor = getAnchorElement(anchorElement, getAnchorRectProp);\n      const updatePosition2 = async () => {\n        if (!mounted)\n          return;\n        const middleware = [\n          getOffsetMiddleware(arrowElement, { gutter, shift: shift2 }),\n          getFlipMiddleware({ flip: flip2, overflowPadding }),\n          getShiftMiddleware({ slide, shift: shift2, overlap, overflowPadding }),\n          getArrowMiddleware(arrowElement, { arrowPadding }),\n          getSizeMiddleware({\n            sameWidth,\n            fitViewport,\n            overflowPadding\n          })\n        ];\n        const pos = await computePosition(anchor, popoverElement, {\n          placement,\n          strategy: fixed ? \"fixed\" : \"absolute\",\n          middleware\n        });\n        store == null ? void 0 : store.setState(\"currentPlacement\", pos.placement);\n        setPositioned(true);\n        const x = roundByDPR(pos.x);\n        const y = roundByDPR(pos.y);\n        Object.assign(popoverElement.style, {\n          top: \"0\",\n          left: \"0\",\n          transform: `translate3d(${x}px,${y}px,0)`\n        });\n        if (arrowElement && pos.middlewareData.arrow) {\n          const { x: arrowX, y: arrowY } = pos.middlewareData.arrow;\n          const dir = pos.placement.split(\"-\")[0];\n          Object.assign(arrowElement.style, {\n            left: arrowX != null ? `${arrowX}px` : \"\",\n            top: arrowY != null ? `${arrowY}px` : \"\",\n            [dir]: \"100%\"\n          });\n        }\n      };\n      const update = async () => {\n        if (hasCustomUpdatePosition) {\n          await updatePositionProp({ updatePosition: updatePosition2 });\n          setPositioned(true);\n        } else {\n          await updatePosition2();\n        }\n      };\n      const cancelAutoUpdate = autoUpdate(anchor, popoverElement, update, {\n        // JSDOM doesn't support ResizeObserver\n        elementResize: typeof ResizeObserver === \"function\"\n      });\n      return () => {\n        setPositioned(false);\n        cancelAutoUpdate();\n      };\n    }, [\n      store,\n      rendered,\n      popoverElement,\n      arrowElement,\n      anchorElement,\n      popoverElement,\n      placement,\n      mounted,\n      domReady,\n      fixed,\n      flip2,\n      shift2,\n      slide,\n      overlap,\n      sameWidth,\n      fitViewport,\n      gutter,\n      arrowPadding,\n      overflowPadding,\n      getAnchorRectProp,\n      hasCustomUpdatePosition,\n      updatePositionProp\n    ]);\n    useSafeLayoutEffect(() => {\n      if (!mounted)\n        return;\n      if (!domReady)\n        return;\n      if (!(popoverElement == null ? void 0 : popoverElement.isConnected))\n        return;\n      if (!(contentElement == null ? void 0 : contentElement.isConnected))\n        return;\n      const applyZIndex = () => {\n        popoverElement.style.zIndex = getComputedStyle(contentElement).zIndex;\n      };\n      applyZIndex();\n      let raf = requestAnimationFrame(() => {\n        raf = requestAnimationFrame(applyZIndex);\n      });\n      return () => cancelAnimationFrame(raf);\n    }, [mounted, domReady, popoverElement, contentElement]);\n    const position = fixed ? \"fixed\" : \"absolute\";\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(\n        \"div\",\n        __spreadProps(__spreadValues({}, wrapperProps), {\n          style: __spreadValues({\n            // https://floating-ui.com/docs/computeposition#initial-layout\n            position,\n            top: 0,\n            left: 0,\n            width: \"max-content\"\n          }, wrapperProps == null ? void 0 : wrapperProps.style),\n          ref: store == null ? void 0 : store.setPopoverElement,\n          children: element\n        })\n      ),\n      [store, position, wrapperProps]\n    );\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(PopoverScopedContextProvider, { value: store, children: element }),\n      [store]\n    );\n    props = __spreadProps(__spreadValues({\n      // data-placing is not part of the public API. We're setting this here so\n      // we can wait for the popover to be positioned before other components\n      // move focus into it. For example, this attribute is observed by the\n      // Combobox component with the autoSelect behavior.\n      \"data-placing\": !positioned || void 0\n    }, props), {\n      style: __spreadValues({\n        position: \"relative\"\n      }, props.style)\n    });\n    props = useDialog(__spreadProps(__spreadValues({\n      store,\n      modal,\n      portal,\n      preserveTabOrder,\n      preserveTabOrderAnchor: disclosureElement || anchorElement,\n      autoFocusOnShow: positioned && autoFocusOnShow\n    }, props), {\n      portalRef\n    }));\n    return props;\n  }\n);\nvar Popover = createDialogComponent(\n  forwardRef(function Popover2(props) {\n    const htmlProps = usePopover(props);\n    return createElement(TagName, htmlProps);\n  }),\n  usePopoverProviderContext\n);\n\nexport {\n  usePopover,\n  Popover\n};\n","\"use client\";\nimport {\n  DialogContextProvider,\n  DialogScopedContextProvider\n} from \"./XXVAHUAO.js\";\nimport {\n  createStoreContext\n} from \"./5M6RSQEC.js\";\n\n// src/popover/popover-context.tsx\nvar ctx = createStoreContext(\n  [DialogContextProvider],\n  [DialogScopedContextProvider]\n);\nvar usePopoverContext = ctx.useContext;\nvar usePopoverScopedContext = ctx.useScopedContext;\nvar usePopoverProviderContext = ctx.useProviderContext;\nvar PopoverContextProvider = ctx.ContextProvider;\nvar PopoverScopedContextProvider = ctx.ScopedContextProvider;\n\nexport {\n  usePopoverContext,\n  usePopoverScopedContext,\n  usePopoverProviderContext,\n  PopoverContextProvider,\n  PopoverScopedContextProvider\n};\n","\"use client\";\nimport {\n  PopoverContextProvider,\n  PopoverScopedContextProvider\n} from \"./TE637IA7.js\";\nimport {\n  createStoreContext\n} from \"./5M6RSQEC.js\";\n\n// src/hovercard/hovercard-context.tsx\nvar ctx = createStoreContext(\n  [PopoverContextProvider],\n  [PopoverScopedContextProvider]\n);\nvar useHovercardContext = ctx.useContext;\nvar useHovercardScopedContext = ctx.useScopedContext;\nvar useHovercardProviderContext = ctx.useProviderContext;\nvar HovercardContextProvider = ctx.ContextProvider;\nvar HovercardScopedContextProvider = ctx.ScopedContextProvider;\n\nexport {\n  useHovercardContext,\n  useHovercardScopedContext,\n  useHovercardProviderContext,\n  HovercardContextProvider,\n  HovercardScopedContextProvider\n};\n","\"use client\";\nimport {\n  usePopoverStoreProps\n} from \"./XWCFCD3Q.js\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./EKQEJRUF.js\";\n\n// src/hovercard/hovercard-store.ts\nimport * as Core from \"@ariakit/core/hovercard/hovercard-store\";\nfunction useHovercardStoreProps(store, update, props) {\n  useStoreProps(store, props, \"timeout\");\n  useStoreProps(store, props, \"showTimeout\");\n  useStoreProps(store, props, \"hideTimeout\");\n  return usePopoverStoreProps(store, update, props);\n}\nfunction useHovercardStore(props = {}) {\n  const [store, update] = useStore(Core.createHovercardStore, props);\n  return useHovercardStoreProps(store, update, props);\n}\n\nexport {\n  useHovercardStoreProps,\n  useHovercardStore\n};\n","\"use client\";\nimport {\n  createHovercardStore\n} from \"../__chunks/BRS7GKWU.js\";\nimport \"../__chunks/MFZZDIHG.js\";\nimport \"../__chunks/5RJNXXU2.js\";\nimport \"../__chunks/WCKXDMU7.js\";\nimport {\n  createStore\n} from \"../__chunks/R676XYVY.js\";\nimport {\n  defaultValue\n} from \"../__chunks/22HHDS5F.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/4R3V3JGP.js\";\n\n// src/tooltip/tooltip-store.ts\nfunction createTooltipStore(props = {}) {\n  var _a;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (props.type === \"label\") {\n      console.warn(\n        \"The `type` option on the tooltip store is deprecated.\",\n        \"Render a visually hidden label or use the `aria-label` or `aria-labelledby` attributes on the anchor element instead.\",\n        \"See https://ariakit.org/components/tooltip#tooltip-anchors-must-have-accessible-names\"\n      );\n    }\n  }\n  const syncState = (_a = props.store) == null ? void 0 : _a.getState();\n  const hovercard = createHovercardStore(__spreadProps(__spreadValues({}, props), {\n    placement: defaultValue(\n      props.placement,\n      syncState == null ? void 0 : syncState.placement,\n      \"top\"\n    ),\n    hideTimeout: defaultValue(props.hideTimeout, syncState == null ? void 0 : syncState.hideTimeout, 0)\n  }));\n  const initialState = __spreadProps(__spreadValues({}, hovercard.getState()), {\n    type: defaultValue(props.type, syncState == null ? void 0 : syncState.type, \"description\"),\n    skipTimeout: defaultValue(props.skipTimeout, syncState == null ? void 0 : syncState.skipTimeout, 300)\n  });\n  const tooltip = createStore(initialState, hovercard, props.store);\n  return __spreadValues(__spreadValues({}, hovercard), tooltip);\n}\nexport {\n  createTooltipStore\n};\n","\"use client\";\nimport {\n  createPopoverStore\n} from \"./MFZZDIHG.js\";\nimport {\n  createStore\n} from \"./R676XYVY.js\";\nimport {\n  defaultValue\n} from \"./22HHDS5F.js\";\nimport {\n  __spreadProps,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/hovercard/hovercard-store.ts\nfunction createHovercardStore(props = {}) {\n  var _a;\n  const syncState = (_a = props.store) == null ? void 0 : _a.getState();\n  const popover = createPopoverStore(__spreadProps(__spreadValues({}, props), {\n    placement: defaultValue(\n      props.placement,\n      syncState == null ? void 0 : syncState.placement,\n      \"bottom\"\n    )\n  }));\n  const timeout = defaultValue(props.timeout, syncState == null ? void 0 : syncState.timeout, 500);\n  const initialState = __spreadProps(__spreadValues({}, popover.getState()), {\n    timeout,\n    showTimeout: defaultValue(props.showTimeout, syncState == null ? void 0 : syncState.showTimeout),\n    hideTimeout: defaultValue(props.hideTimeout, syncState == null ? void 0 : syncState.hideTimeout),\n    autoFocusOnShow: defaultValue(syncState == null ? void 0 : syncState.autoFocusOnShow, false)\n  });\n  const hovercard = createStore(initialState, popover, props.store);\n  return __spreadProps(__spreadValues(__spreadValues({}, popover), hovercard), {\n    setAutoFocusOnShow: (value) => hovercard.setState(\"autoFocusOnShow\", value)\n  });\n}\n\nexport {\n  createHovercardStore\n};\n","\"use client\";\nimport {\n  useHovercardStoreProps\n} from \"./E5E7G32I.js\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./EKQEJRUF.js\";\n\n// src/tooltip/tooltip-store.ts\nimport * as Core from \"@ariakit/core/tooltip/tooltip-store\";\nfunction useTooltipStoreProps(store, update, props) {\n  useStoreProps(store, props, \"type\");\n  useStoreProps(store, props, \"skipTimeout\");\n  return useHovercardStoreProps(store, update, props);\n}\nfunction useTooltipStore(props = {}) {\n  const [store, update] = useStore(Core.createTooltipStore, props);\n  return useTooltipStoreProps(store, update, props);\n}\n\nexport {\n  useTooltipStoreProps,\n  useTooltipStore\n};\n","\"use client\";\nimport {\n  useDialogStoreProps\n} from \"./I62TROYO.js\";\nimport {\n  useStore,\n  useStoreProps\n} from \"./EKQEJRUF.js\";\nimport {\n  useUpdateEffect\n} from \"./6O5OEQGF.js\";\n\n// src/popover/popover-store.ts\nimport * as Core from \"@ariakit/core/popover/popover-store\";\nfunction usePopoverStoreProps(store, update, props) {\n  useUpdateEffect(update, [props.popover]);\n  useStoreProps(store, props, \"placement\");\n  return useDialogStoreProps(store, update, props);\n}\nfunction usePopoverStore(props = {}) {\n  const [store, update] = useStore(Core.createPopoverStore, props);\n  return usePopoverStoreProps(store, update, props);\n}\n\nexport {\n  usePopoverStoreProps,\n  usePopoverStore\n};\n","\"use client\";\nimport {\n  useHovercardProviderContext\n} from \"./TWDHCE7Y.js\";\nimport {\n  useFocusable\n} from \"./WAZE6NXP.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./5M6RSQEC.js\";\nimport {\n  useBooleanEvent,\n  useEvent,\n  useIsMouseMoving,\n  useMergeRefs\n} from \"./6O5OEQGF.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/hovercard/hovercard-anchor.ts\nimport { useCallback, useEffect, useRef } from \"react\";\nimport { addGlobalEventListener } from \"@ariakit/core/utils/events\";\nimport { disabledFromProps, invariant } from \"@ariakit/core/utils/misc\";\nvar TagName = \"a\";\nvar useHovercardAnchor = createHook(\n  function useHovercardAnchor2(_a) {\n    var _b = _a, { store, showOnHover = true } = _b, props = __objRest(_b, [\"store\", \"showOnHover\"]);\n    const context = useHovercardProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"HovercardAnchor must receive a `store` prop or be wrapped in a HovercardProvider component.\"\n    );\n    const disabled = disabledFromProps(props);\n    const showTimeoutRef = useRef(0);\n    useEffect(() => () => window.clearTimeout(showTimeoutRef.current), []);\n    useEffect(() => {\n      const onMouseLeave = (event) => {\n        if (!store)\n          return;\n        const { anchorElement } = store.getState();\n        if (!anchorElement)\n          return;\n        if (event.target !== anchorElement)\n          return;\n        window.clearTimeout(showTimeoutRef.current);\n        showTimeoutRef.current = 0;\n      };\n      return addGlobalEventListener(\"mouseleave\", onMouseLeave, true);\n    }, [store]);\n    const onMouseMoveProp = props.onMouseMove;\n    const showOnHoverProp = useBooleanEvent(showOnHover);\n    const isMouseMoving = useIsMouseMoving();\n    const onMouseMove = useEvent((event) => {\n      onMouseMoveProp == null ? void 0 : onMouseMoveProp(event);\n      if (disabled)\n        return;\n      if (!store)\n        return;\n      if (event.defaultPrevented)\n        return;\n      if (showTimeoutRef.current)\n        return;\n      if (!isMouseMoving())\n        return;\n      if (!showOnHoverProp(event))\n        return;\n      const element = event.currentTarget;\n      store.setAnchorElement(element);\n      store.setDisclosureElement(element);\n      const { showTimeout, timeout } = store.getState();\n      const showHovercard = () => {\n        showTimeoutRef.current = 0;\n        if (!isMouseMoving())\n          return;\n        store == null ? void 0 : store.setAnchorElement(element);\n        store == null ? void 0 : store.show();\n        queueMicrotask(() => {\n          store == null ? void 0 : store.setDisclosureElement(element);\n        });\n      };\n      const timeoutMs = showTimeout != null ? showTimeout : timeout;\n      if (timeoutMs === 0) {\n        showHovercard();\n      } else {\n        showTimeoutRef.current = window.setTimeout(showHovercard, timeoutMs);\n      }\n    });\n    const ref = useCallback(\n      (element) => {\n        if (!store)\n          return;\n        const { anchorElement } = store.getState();\n        if (anchorElement == null ? void 0 : anchorElement.isConnected)\n          return;\n        store.setAnchorElement(element);\n      },\n      [store]\n    );\n    props = __spreadProps(__spreadValues({}, props), {\n      ref: useMergeRefs(ref, props.ref),\n      onMouseMove\n    });\n    props = useFocusable(props);\n    return props;\n  }\n);\nvar HovercardAnchor = forwardRef(function HovercardAnchor2(props) {\n  const htmlProps = useHovercardAnchor(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  useHovercardAnchor,\n  HovercardAnchor\n};\n","\"use client\";\nimport {\n  useHovercardAnchor\n} from \"../__chunks/FWINX72I.js\";\nimport {\n  useTooltipProviderContext\n} from \"../__chunks/3OMHZVJD.js\";\nimport \"../__chunks/TWDHCE7Y.js\";\nimport \"../__chunks/TE637IA7.js\";\nimport \"../__chunks/XXVAHUAO.js\";\nimport \"../__chunks/J55AVALY.js\";\nimport \"../__chunks/WAZE6NXP.js\";\nimport \"../__chunks/SHA3WOPI.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/5M6RSQEC.js\";\nimport {\n  useEvent\n} from \"../__chunks/6O5OEQGF.js\";\nimport \"../__chunks/XM66DUTO.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/4R3V3JGP.js\";\n\n// src/tooltip/tooltip-anchor.ts\nimport { useEffect, useRef } from \"react\";\nimport { invariant, isFalsyBooleanCallback } from \"@ariakit/core/utils/misc\";\nimport { createStore, sync } from \"@ariakit/core/utils/store\";\nvar TagName = \"div\";\nvar globalStore = createStore({\n  activeStore: null\n});\nvar useTooltipAnchor = createHook(\n  function useTooltipAnchor2(_a) {\n    var _b = _a, { store, showOnHover = true } = _b, props = __objRest(_b, [\"store\", \"showOnHover\"]);\n    const context = useTooltipProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"TooltipAnchor must receive a `store` prop or be wrapped in a TooltipProvider component.\"\n    );\n    const canShowOnHoverRef = useRef(false);\n    useEffect(() => {\n      return sync(store, [\"mounted\"], (state) => {\n        if (state.mounted)\n          return;\n        canShowOnHoverRef.current = false;\n      });\n    }, [store]);\n    useEffect(() => {\n      return sync(store, [\"mounted\", \"skipTimeout\"], (state) => {\n        if (!store)\n          return;\n        if (state.mounted) {\n          const { activeStore } = globalStore.getState();\n          if (activeStore !== store) {\n            activeStore == null ? void 0 : activeStore.hide();\n          }\n          return globalStore.setState(\"activeStore\", store);\n        }\n        const id = setTimeout(() => {\n          const { activeStore } = globalStore.getState();\n          if (activeStore !== store)\n            return;\n          globalStore.setState(\"activeStore\", null);\n        }, state.skipTimeout);\n        return () => clearTimeout(id);\n      });\n    }, [store]);\n    const onMouseEnterProp = props.onMouseEnter;\n    const onMouseEnter = useEvent((event) => {\n      onMouseEnterProp == null ? void 0 : onMouseEnterProp(event);\n      canShowOnHoverRef.current = true;\n    });\n    const onFocusVisibleProp = props.onFocusVisible;\n    const onFocusVisible = useEvent((event) => {\n      onFocusVisibleProp == null ? void 0 : onFocusVisibleProp(event);\n      if (event.defaultPrevented)\n        return;\n      store == null ? void 0 : store.setAnchorElement(event.currentTarget);\n      store == null ? void 0 : store.show();\n    });\n    const onBlurProp = props.onBlur;\n    const onBlur = useEvent((event) => {\n      onBlurProp == null ? void 0 : onBlurProp(event);\n      if (event.defaultPrevented)\n        return;\n      const { activeStore } = globalStore.getState();\n      if (activeStore === store) {\n        globalStore.setState(\"activeStore\", null);\n      }\n    });\n    const type = store.useState(\"type\");\n    const contentId = store.useState((state) => {\n      var _a2;\n      return (_a2 = state.contentElement) == null ? void 0 : _a2.id;\n    });\n    props = __spreadProps(__spreadValues({\n      \"aria-labelledby\": type === \"label\" ? contentId : void 0\n    }, props), {\n      onMouseEnter,\n      onFocusVisible,\n      onBlur\n    });\n    props = useHovercardAnchor(__spreadValues({\n      store,\n      showOnHover(event) {\n        if (!canShowOnHoverRef.current)\n          return false;\n        if (isFalsyBooleanCallback(showOnHover, event))\n          return false;\n        const { activeStore } = globalStore.getState();\n        if (!activeStore)\n          return true;\n        store == null ? void 0 : store.show();\n        return false;\n      }\n    }, props));\n    return props;\n  }\n);\nvar TooltipAnchor = forwardRef(function TooltipAnchor2(props) {\n  const htmlProps = useTooltipAnchor(props);\n  return createElement(TagName, htmlProps);\n});\nexport {\n  TooltipAnchor,\n  useTooltipAnchor\n};\n","\"use client\";\n\n// src/popover/popover-arrow-path.ts\nvar POPOVER_ARROW_PATH = \"M23,27.8c1.1,1.2,3.4,2.2,5,2.2h2H0h2c1.7,0,3.9-1,5-2.2l6.6-7.2c0.7-0.8,2-0.8,2.7,0L23,27.8L23,27.8z\";\n\nexport {\n  POPOVER_ARROW_PATH\n};\n","\"use client\";\nimport {\n  POPOVER_ARROW_PATH\n} from \"./QFL5V2DO.js\";\nimport {\n  usePopoverContext\n} from \"./TE637IA7.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./5M6RSQEC.js\";\nimport {\n  useMergeRefs,\n  useSafeLayoutEffect\n} from \"./6O5OEQGF.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/popover/popover-arrow.tsx\nimport { useMemo, useState } from \"react\";\nimport { getWindow } from \"@ariakit/core/utils/dom\";\nimport { invariant, removeUndefinedValues } from \"@ariakit/core/utils/misc\";\nimport { jsx, jsxs } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nvar defaultSize = 30;\nvar halfDefaultSize = defaultSize / 2;\nvar rotateMap = {\n  top: `rotate(180 ${halfDefaultSize} ${halfDefaultSize})`,\n  right: `rotate(-90 ${halfDefaultSize} ${halfDefaultSize})`,\n  bottom: `rotate(0 ${halfDefaultSize} ${halfDefaultSize})`,\n  left: `rotate(90 ${halfDefaultSize} ${halfDefaultSize})`\n};\nfunction useComputedStyle(store) {\n  const [style, setStyle] = useState();\n  const contentElement = store.useState(\"contentElement\");\n  useSafeLayoutEffect(() => {\n    if (!contentElement)\n      return;\n    const win = getWindow(contentElement);\n    const computedStyle = win.getComputedStyle(contentElement);\n    setStyle(computedStyle);\n  }, [contentElement]);\n  return style;\n}\nvar usePopoverArrow = createHook(\n  function usePopoverArrow2(_a) {\n    var _b = _a, { store, size = defaultSize } = _b, props = __objRest(_b, [\"store\", \"size\"]);\n    const context = usePopoverContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"PopoverArrow must be wrapped in a Popover component.\"\n    );\n    const dir = store.useState(\n      (state) => state.currentPlacement.split(\"-\")[0]\n    );\n    const style = useComputedStyle(store);\n    const fill = (style == null ? void 0 : style.getPropertyValue(\"background-color\")) || \"none\";\n    const stroke = (style == null ? void 0 : style.getPropertyValue(`border-${dir}-color`)) || \"none\";\n    const borderWidth = (style == null ? void 0 : style.getPropertyValue(`border-${dir}-width`)) || \"0px\";\n    const strokeWidth = parseInt(borderWidth) * 2 * (defaultSize / size);\n    const transform = rotateMap[dir];\n    const children = useMemo(\n      () => /* @__PURE__ */ jsx(\"svg\", { display: \"block\", viewBox: \"0 0 30 30\", children: /* @__PURE__ */ jsxs(\"g\", { transform, children: [\n        /* @__PURE__ */ jsx(\"path\", { fill: \"none\", d: POPOVER_ARROW_PATH }),\n        /* @__PURE__ */ jsx(\"path\", { stroke: \"none\", d: POPOVER_ARROW_PATH })\n      ] }) }),\n      [transform]\n    );\n    props = __spreadProps(__spreadValues({\n      children,\n      \"aria-hidden\": true\n    }, props), {\n      ref: useMergeRefs(store.setArrowElement, props.ref),\n      style: __spreadValues({\n        // server side rendering\n        position: \"absolute\",\n        fontSize: size,\n        width: \"1em\",\n        height: \"1em\",\n        pointerEvents: \"none\",\n        fill,\n        stroke,\n        strokeWidth\n      }, props.style)\n    });\n    return removeUndefinedValues(props);\n  }\n);\nvar PopoverArrow = forwardRef(function PopoverArrow2(props) {\n  const htmlProps = usePopoverArrow(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport {\n  usePopoverArrow,\n  PopoverArrow\n};\n","\"use client\";\nimport {\n  usePopoverArrow\n} from \"../__chunks/UFM3D5TN.js\";\nimport \"../__chunks/QFL5V2DO.js\";\nimport {\n  useTooltipContext\n} from \"../__chunks/3OMHZVJD.js\";\nimport \"../__chunks/TWDHCE7Y.js\";\nimport \"../__chunks/TE637IA7.js\";\nimport \"../__chunks/XXVAHUAO.js\";\nimport \"../__chunks/J55AVALY.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/5M6RSQEC.js\";\nimport \"../__chunks/6O5OEQGF.js\";\nimport \"../__chunks/XM66DUTO.js\";\nimport {\n  __objRest,\n  __spreadValues\n} from \"../__chunks/4R3V3JGP.js\";\n\n// src/tooltip/tooltip-arrow.ts\nimport { invariant } from \"@ariakit/core/utils/misc\";\nvar TagName = \"div\";\nvar useTooltipArrow = createHook(\n  function useTooltipArrow2(_a) {\n    var _b = _a, { store, size = 16 } = _b, props = __objRest(_b, [\"store\", \"size\"]);\n    const context = useTooltipContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"TooltipArrow must be wrapped in a Tooltip component.\"\n    );\n    props = usePopoverArrow(__spreadValues({ store, size }, props));\n    return props;\n  }\n);\nvar TooltipArrow = forwardRef(function TooltipArrow2(props) {\n  const htmlProps = useTooltipArrow(props);\n  return createElement(TagName, htmlProps);\n});\nexport {\n  TooltipArrow,\n  useTooltipArrow\n};\n","\"use client\";\n\n// src/hovercard/utils/polygon.ts\nfunction getEventPoint(event) {\n  return [event.clientX, event.clientY];\n}\nfunction isPointInPolygon(point, polygon) {\n  const [x, y] = point;\n  let inside = false;\n  const length = polygon.length;\n  for (let l = length, i = 0, j = l - 1; i < l; j = i++) {\n    const [xi, yi] = polygon[i];\n    const [xj, yj] = polygon[j];\n    const [, vy] = polygon[j === 0 ? l - 1 : j - 1] || [0, 0];\n    const where = (yi - yj) * (x - xi) - (xi - xj) * (y - yi);\n    if (yj < yi) {\n      if (y >= yj && y < yi) {\n        if (where === 0)\n          return true;\n        if (where > 0) {\n          if (y === yj) {\n            if (y > vy) {\n              inside = !inside;\n            }\n          } else {\n            inside = !inside;\n          }\n        }\n      }\n    } else if (yi < yj) {\n      if (y > yi && y <= yj) {\n        if (where === 0)\n          return true;\n        if (where < 0) {\n          if (y === yj) {\n            if (y < vy) {\n              inside = !inside;\n            }\n          } else {\n            inside = !inside;\n          }\n        }\n      }\n    } else if (y == yi && (x >= xj && x <= xi || x >= xi && x <= xj)) {\n      return true;\n    }\n  }\n  return inside;\n}\nfunction getEnterPointPlacement(enterPoint, rect) {\n  const { top, right, bottom, left } = rect;\n  const [x, y] = enterPoint;\n  const placementX = x < left ? \"left\" : x > right ? \"right\" : null;\n  const placementY = y < top ? \"top\" : y > bottom ? \"bottom\" : null;\n  return [placementX, placementY];\n}\nfunction getElementPolygon(element, enterPoint) {\n  const rect = element.getBoundingClientRect();\n  const { top, right, bottom, left } = rect;\n  const [x, y] = getEnterPointPlacement(enterPoint, rect);\n  const polygon = [enterPoint];\n  if (x) {\n    if (y !== \"top\") {\n      polygon.push([x === \"left\" ? left : right, top]);\n    }\n    polygon.push([x === \"left\" ? right : left, top]);\n    polygon.push([x === \"left\" ? right : left, bottom]);\n    if (y !== \"bottom\") {\n      polygon.push([x === \"left\" ? left : right, bottom]);\n    }\n  } else if (y === \"top\") {\n    polygon.push([left, top]);\n    polygon.push([left, bottom]);\n    polygon.push([right, bottom]);\n    polygon.push([right, top]);\n  } else {\n    polygon.push([left, bottom]);\n    polygon.push([left, top]);\n    polygon.push([right, top]);\n    polygon.push([right, bottom]);\n  }\n  return polygon;\n}\n\nexport {\n  getEventPoint,\n  isPointInPolygon,\n  getElementPolygon\n};\n","\"use client\";\nimport {\n  getElementPolygon,\n  getEventPoint,\n  isPointInPolygon\n} from \"./YMV43K4F.js\";\nimport {\n  usePopover\n} from \"./BYD75WXE.js\";\nimport {\n  createDialogComponent\n} from \"./KXSO5EFT.js\";\nimport {\n  HovercardScopedContextProvider,\n  useHovercardProviderContext\n} from \"./TWDHCE7Y.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"./5M6RSQEC.js\";\nimport {\n  useBooleanEvent,\n  useEvent,\n  useLiveRef,\n  useMergeRefs,\n  usePortalRef,\n  useSafeLayoutEffect,\n  useWrapElement\n} from \"./6O5OEQGF.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"./4R3V3JGP.js\";\n\n// src/hovercard/hovercard.tsx\nimport {\n  createContext,\n  useCallback,\n  useContext,\n  useEffect,\n  useRef,\n  useState\n} from \"react\";\nimport { contains } from \"@ariakit/core/utils/dom\";\nimport { addGlobalEventListener } from \"@ariakit/core/utils/events\";\nimport { hasFocusWithin } from \"@ariakit/core/utils/focus\";\nimport {\n  chain,\n  invariant,\n  isFalsyBooleanCallback\n} from \"@ariakit/core/utils/misc\";\nimport { sync } from \"@ariakit/core/utils/store\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nfunction isMovingOnHovercard(target, card, anchor, nested) {\n  if (hasFocusWithin(card))\n    return true;\n  if (!target)\n    return false;\n  if (contains(card, target))\n    return true;\n  if (anchor && contains(anchor, target))\n    return true;\n  if (nested == null ? void 0 : nested.some((card2) => isMovingOnHovercard(target, card2, anchor))) {\n    return true;\n  }\n  return false;\n}\nfunction useAutoFocusOnHide(_a) {\n  var _b = _a, {\n    store\n  } = _b, props = __objRest(_b, [\n    \"store\"\n  ]);\n  const [autoFocusOnHide, setAutoFocusOnHide] = useState(false);\n  const mounted = store.useState(\"mounted\");\n  useEffect(() => {\n    if (!mounted) {\n      setAutoFocusOnHide(false);\n    }\n  }, [mounted]);\n  const onFocusProp = props.onFocus;\n  const onFocus = useEvent((event) => {\n    onFocusProp == null ? void 0 : onFocusProp(event);\n    if (event.defaultPrevented)\n      return;\n    setAutoFocusOnHide(true);\n  });\n  const finalFocusRef = useRef(null);\n  useEffect(() => {\n    return sync(store, [\"anchorElement\"], (state) => {\n      finalFocusRef.current = state.anchorElement;\n    });\n  }, []);\n  props = __spreadProps(__spreadValues({\n    autoFocusOnHide,\n    finalFocus: finalFocusRef\n  }, props), {\n    onFocus\n  });\n  return props;\n}\nvar NestedHovercardContext = createContext(null);\nvar useHovercard = createHook(\n  function useHovercard2(_a) {\n    var _b = _a, {\n      store,\n      modal = false,\n      portal = !!modal,\n      hideOnEscape = true,\n      hideOnHoverOutside = true,\n      disablePointerEventsOnApproach = !!hideOnHoverOutside\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"modal\",\n      \"portal\",\n      \"hideOnEscape\",\n      \"hideOnHoverOutside\",\n      \"disablePointerEventsOnApproach\"\n    ]);\n    const context = useHovercardProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"Hovercard must receive a `store` prop or be wrapped in a HovercardProvider component.\"\n    );\n    const ref = useRef(null);\n    const [nestedHovercards, setNestedHovercards] = useState([]);\n    const hideTimeoutRef = useRef(0);\n    const enterPointRef = useRef(null);\n    const { portalRef, domReady } = usePortalRef(portal, props.portalRef);\n    const mayHideOnHoverOutside = !!hideOnHoverOutside;\n    const hideOnHoverOutsideProp = useBooleanEvent(hideOnHoverOutside);\n    const mayDisablePointerEvents = !!disablePointerEventsOnApproach;\n    const disablePointerEventsProp = useBooleanEvent(\n      disablePointerEventsOnApproach\n    );\n    const open = store.useState(\"open\");\n    const mounted = store.useState(\"mounted\");\n    useEffect(() => {\n      if (!domReady)\n        return;\n      if (!mounted)\n        return;\n      if (!mayHideOnHoverOutside && !mayDisablePointerEvents)\n        return;\n      const element = ref.current;\n      if (!element)\n        return;\n      const onMouseMove = (event) => {\n        if (!store)\n          return;\n        const { anchorElement, hideTimeout, timeout } = store.getState();\n        const enterPoint = enterPointRef.current;\n        const [target] = event.composedPath();\n        const anchor = anchorElement;\n        if (isMovingOnHovercard(target, element, anchor, nestedHovercards)) {\n          enterPointRef.current = target && anchor && contains(anchor, target) ? getEventPoint(event) : null;\n          window.clearTimeout(hideTimeoutRef.current);\n          hideTimeoutRef.current = 0;\n          return;\n        }\n        if (hideTimeoutRef.current)\n          return;\n        if (enterPoint) {\n          const currentPoint = getEventPoint(event);\n          const polygon = getElementPolygon(element, enterPoint);\n          if (isPointInPolygon(currentPoint, polygon)) {\n            enterPointRef.current = currentPoint;\n            if (!disablePointerEventsProp(event))\n              return;\n            event.preventDefault();\n            event.stopPropagation();\n            return;\n          }\n        }\n        if (!hideOnHoverOutsideProp(event))\n          return;\n        hideTimeoutRef.current = window.setTimeout(() => {\n          hideTimeoutRef.current = 0;\n          store == null ? void 0 : store.hide();\n        }, hideTimeout != null ? hideTimeout : timeout);\n      };\n      return chain(\n        addGlobalEventListener(\"mousemove\", onMouseMove, true),\n        () => clearTimeout(hideTimeoutRef.current)\n      );\n    }, [\n      store,\n      domReady,\n      mounted,\n      mayHideOnHoverOutside,\n      mayDisablePointerEvents,\n      nestedHovercards,\n      disablePointerEventsProp,\n      hideOnHoverOutsideProp\n    ]);\n    useEffect(() => {\n      if (!domReady)\n        return;\n      if (!mounted)\n        return;\n      if (!mayDisablePointerEvents)\n        return;\n      const disableEvent = (event) => {\n        const element = ref.current;\n        if (!element)\n          return;\n        const enterPoint = enterPointRef.current;\n        if (!enterPoint)\n          return;\n        const polygon = getElementPolygon(element, enterPoint);\n        if (isPointInPolygon(getEventPoint(event), polygon)) {\n          if (!disablePointerEventsProp(event))\n            return;\n          event.preventDefault();\n          event.stopPropagation();\n        }\n      };\n      return chain(\n        // Note: we may need to add pointer events here in the future.\n        addGlobalEventListener(\"mouseenter\", disableEvent, true),\n        addGlobalEventListener(\"mouseover\", disableEvent, true),\n        addGlobalEventListener(\"mouseout\", disableEvent, true),\n        addGlobalEventListener(\"mouseleave\", disableEvent, true)\n      );\n    }, [domReady, mounted, mayDisablePointerEvents, disablePointerEventsProp]);\n    useEffect(() => {\n      if (!domReady)\n        return;\n      if (open)\n        return;\n      store == null ? void 0 : store.setAutoFocusOnShow(false);\n    }, [store, domReady, open]);\n    const openRef = useLiveRef(open);\n    useEffect(() => {\n      if (!domReady)\n        return;\n      return () => {\n        if (!openRef.current) {\n          store == null ? void 0 : store.setAutoFocusOnShow(false);\n        }\n      };\n    }, [store, domReady]);\n    const registerOnParent = useContext(NestedHovercardContext);\n    useSafeLayoutEffect(() => {\n      if (modal)\n        return;\n      if (!portal)\n        return;\n      if (!mounted)\n        return;\n      if (!domReady)\n        return;\n      const element = ref.current;\n      if (!element)\n        return;\n      return registerOnParent == null ? void 0 : registerOnParent(element);\n    }, [modal, portal, mounted, domReady]);\n    const registerNestedHovercard = useCallback(\n      (element) => {\n        setNestedHovercards((prevElements) => [...prevElements, element]);\n        const parentUnregister = registerOnParent == null ? void 0 : registerOnParent(element);\n        return () => {\n          setNestedHovercards(\n            (prevElements) => prevElements.filter((item) => item !== element)\n          );\n          parentUnregister == null ? void 0 : parentUnregister();\n        };\n      },\n      [registerOnParent]\n    );\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(HovercardScopedContextProvider, { value: store, children: /* @__PURE__ */ jsx(NestedHovercardContext.Provider, { value: registerNestedHovercard, children: element }) }),\n      [store, registerNestedHovercard]\n    );\n    props = __spreadProps(__spreadValues({}, props), {\n      ref: useMergeRefs(ref, props.ref)\n    });\n    props = useAutoFocusOnHide(__spreadValues({ store }, props));\n    const autoFocusOnShow = store.useState(\n      (state) => modal || state.autoFocusOnShow\n    );\n    props = usePopover(__spreadProps(__spreadValues({\n      store,\n      modal,\n      portal,\n      autoFocusOnShow\n    }, props), {\n      portalRef,\n      hideOnEscape(event) {\n        if (isFalsyBooleanCallback(hideOnEscape, event))\n          return false;\n        requestAnimationFrame(() => {\n          requestAnimationFrame(() => {\n            store == null ? void 0 : store.hide();\n          });\n        });\n        return true;\n      }\n    }));\n    return props;\n  }\n);\nvar Hovercard = createDialogComponent(\n  forwardRef(function Hovercard2(props) {\n    const htmlProps = useHovercard(props);\n    return createElement(TagName, htmlProps);\n  }),\n  useHovercardProviderContext\n);\n\nexport {\n  useHovercard,\n  Hovercard\n};\n","\"use client\";\nimport {\n  useHovercard\n} from \"../__chunks/6YZEXKNV.js\";\nimport \"../__chunks/YMV43K4F.js\";\nimport \"../__chunks/BYD75WXE.js\";\nimport {\n  createDialogComponent\n} from \"../__chunks/KXSO5EFT.js\";\nimport \"../__chunks/3N4FFVWW.js\";\nimport \"../__chunks/NOYDL3YS.js\";\nimport \"../__chunks/BULCTPRV.js\";\nimport \"../__chunks/6BJGLK2C.js\";\nimport \"../__chunks/CS347UVZ.js\";\nimport \"../__chunks/IUB2BTEK.js\";\nimport \"../__chunks/XHJGS6Z5.js\";\nimport \"../__chunks/TL67WVI6.js\";\nimport \"../__chunks/MKDDWKFK.js\";\nimport \"../__chunks/72E5EPFF.js\";\nimport \"../__chunks/OOBDFMJL.js\";\nimport \"../__chunks/X6WIMZJE.js\";\nimport \"../__chunks/677M2CI3.js\";\nimport \"../__chunks/6GXEOXGT.js\";\nimport \"../__chunks/WCIYB4YS.js\";\nimport \"../__chunks/UYRJLDVS.js\";\nimport \"../__chunks/CK3UW3AQ.js\";\nimport \"../__chunks/WKWX2XLD.js\";\nimport \"../__chunks/7452U3HH.js\";\nimport \"../__chunks/XPF5GU3Q.js\";\nimport \"../__chunks/CBTO7DFZ.js\";\nimport \"../__chunks/RQZGFHI2.js\";\nimport {\n  TooltipScopedContextProvider,\n  useTooltipProviderContext\n} from \"../__chunks/3OMHZVJD.js\";\nimport \"../__chunks/TWDHCE7Y.js\";\nimport \"../__chunks/TE637IA7.js\";\nimport \"../__chunks/XXVAHUAO.js\";\nimport \"../__chunks/J55AVALY.js\";\nimport \"../__chunks/WAZE6NXP.js\";\nimport \"../__chunks/SHA3WOPI.js\";\nimport \"../__chunks/IFT5JEUU.js\";\nimport {\n  createElement,\n  createHook,\n  forwardRef\n} from \"../__chunks/5M6RSQEC.js\";\nimport \"../__chunks/I62TROYO.js\";\nimport \"../__chunks/HZJ2XALY.js\";\nimport \"../__chunks/EKQEJRUF.js\";\nimport {\n  useWrapElement\n} from \"../__chunks/6O5OEQGF.js\";\nimport \"../__chunks/XM66DUTO.js\";\nimport {\n  __objRest,\n  __spreadProps,\n  __spreadValues\n} from \"../__chunks/4R3V3JGP.js\";\n\n// src/tooltip/tooltip.tsx\nimport { contains } from \"@ariakit/core/utils/dom\";\nimport { invariant, isFalsyBooleanCallback } from \"@ariakit/core/utils/misc\";\nimport { jsx } from \"react/jsx-runtime\";\nvar TagName = \"div\";\nvar useTooltip = createHook(\n  function useTooltip2(_a) {\n    var _b = _a, {\n      store,\n      portal = true,\n      gutter = 8,\n      preserveTabOrder = false,\n      hideOnHoverOutside = true,\n      hideOnInteractOutside = true\n    } = _b, props = __objRest(_b, [\n      \"store\",\n      \"portal\",\n      \"gutter\",\n      \"preserveTabOrder\",\n      \"hideOnHoverOutside\",\n      \"hideOnInteractOutside\"\n    ]);\n    const context = useTooltipProviderContext();\n    store = store || context;\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" && \"Tooltip must receive a `store` prop or be wrapped in a TooltipProvider component.\"\n    );\n    props = useWrapElement(\n      props,\n      (element) => /* @__PURE__ */ jsx(TooltipScopedContextProvider, { value: store, children: element }),\n      [store]\n    );\n    const role = store.useState(\n      (state) => state.type === \"description\" ? \"tooltip\" : \"none\"\n    );\n    props = __spreadValues({ role }, props);\n    props = useHovercard(__spreadProps(__spreadValues({}, props), {\n      store,\n      portal,\n      gutter,\n      preserveTabOrder,\n      hideOnHoverOutside(event) {\n        if (isFalsyBooleanCallback(hideOnHoverOutside, event))\n          return false;\n        const anchorElement = store == null ? void 0 : store.getState().anchorElement;\n        if (!anchorElement)\n          return true;\n        if (\"focusVisible\" in anchorElement.dataset)\n          return false;\n        return true;\n      },\n      hideOnInteractOutside: (event) => {\n        if (isFalsyBooleanCallback(hideOnInteractOutside, event))\n          return false;\n        const anchorElement = store == null ? void 0 : store.getState().anchorElement;\n        if (!anchorElement)\n          return true;\n        if (contains(anchorElement, event.target))\n          return false;\n        return true;\n      }\n    }));\n    return props;\n  }\n);\nvar Tooltip = createDialogComponent(\n  forwardRef(function Tooltip2(props) {\n    const htmlProps = useTooltip(props);\n    return createElement(TagName, htmlProps);\n  }),\n  useTooltipProviderContext\n);\nexport {\n  Tooltip,\n  useTooltip\n};\n"],"names":["hasPassiveEvents","window","passiveTestOptions","passive","addEventListener","removeEventListener","isIosDevice","navigator","platform","test","maxTouchPoints","locks","documentListenerAdded","initialClientY","previousBodyOverflowSetting","previousBodyPaddingRight","allowTouchMove","el","some","lock","options","preventDefault","rawEvent","e","event","target","touches","length","restoreOverflowSetting","undefined","document","body","style","paddingRight","overflow","disableBodyScroll","targetElement","concat","arr","Array","isArray","i","arr2","from","_toConsumableArray","ontouchstart","targetTouches","clientY","ontouchmove","scrollTop","scrollHeight","clientHeight","isTargetElementTotallyScrolled","stopPropagation","handleScroll","_reserveScrollBarGap","reserveScrollBarGap","scrollBarGap","innerWidth","documentElement","clientWidth","setOverflowHidden","console","error","enableBodyScroll","filter","NAN","symbolTag","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","freeGlobal","g","Object","freeSelf","self","root","Function","objectToString","prototype","toString","nativeMax","Math","max","nativeMin","min","now","Date","isObject","value","type","toNumber","isObjectLike","call","isSymbol","other","valueOf","replace","isBinary","slice","module","exports","func","wait","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","apply","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","setTimeout","remainingWait","debounced","isInvoking","arguments","this","leadingEdge","cancel","clearTimeout","flush","createPopoverStore","_a","_b","popover","otherPopover","props","store","syncState","getState","dialog","placement","initialState","currentPlacement","anchorElement","popoverElement","arrowElement","rendered","Symbol","setAnchorElement","element","setState","setPopoverElement","setArrowElement","render","ctx","useTooltipContext","useContext","useTooltipProviderContext","useScopedContext","useProviderContext","TooltipScopedContextProvider","ContextProvider","ScopedContextProvider","round","floor","createCoords","v","x","y","oppositeSideMap","left","right","bottom","top","oppositeAlignmentMap","start","end","clamp","param","split","getOppositeAxis","axis","getAxisLength","includes","getAlignmentAxis","alignment","getOppositePlacement","side","padding","expandPaddingObject","rect","width","height","computeCoordsFromPlacement","_ref","rtl","reference","floating","sideAxis","alignmentAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","async","detectOverflow","state","_await$platform$isEle","rects","elements","strategy","boundary","rootBoundary","elementContext","altBoundary","paddingObject","clippingClientRect","getClippingRect","isElement","contextElement","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","flip","name","fn","_middlewareData$arrow","_middlewareData$flip","middlewareData","initialPlacement","mainAxis","checkMainAxis","crossAxis","checkCrossAxis","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","detectOverflowOptions","arrow","alignmentOffset","isBasePlacement","isRTL","oppositePlacement","getExpandedPlacements","push","direction","list","isStart","lr","rl","tb","bt","getSideList","map","getOppositeAxisPlacements","placements","overflows","overflowsData","sides","mainAlignmentSide","every","_middlewareData$flip2","_overflowsData$filter","nextIndex","index","nextPlacement","data","reset","resetPlacement","d","sort","a","b","_overflowsData$map$so","reduce","acc","offset","diffCoords","mainAxisMulti","crossAxisMulti","rawValue","convertValueToCoords","getNodeName","node","isNode","nodeName","toLowerCase","getWindow","_node$ownerDocument","ownerDocument","defaultView","Node","Element","isHTMLElement","HTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","overflowX","overflowY","display","isTableElement","isContainingBlock","webkit","isWebKit","css","transform","perspective","containerType","backdropFilter","willChange","contain","CSS","supports","isLastTraversableNode","getComputedStyle","getNodeScroll","scrollLeft","pageXOffset","pageYOffset","getParentNode","assignedSlot","parentNode","host","getNearestOverflowAncestor","getOverflowAncestors","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","win","visualViewport","frameElement","getCssDimensions","parseFloat","hasOffset","offsetWidth","offsetHeight","shouldFallback","$","unwrapElement","domElement","getBoundingClientRect","Number","isFinite","noOffsets","getVisualOffsets","offsetLeft","offsetTop","includeScale","isFixedStrategy","clientRect","scale","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","offsetWin","currentIFrame","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getWindowScrollBarX","getClientRectFromClippingAncestor","clippingAncestor","html","visualViewportBased","getViewportRect","scroll","scrollWidth","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","position","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","getTrueOffsetParent","polyfill","currentNode","getContainingBlock","clippingAncestors","cache","cachedResult","get","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","ancestor","set","getClippingElementAncestors","_c","firstClippingAncestor","clippingRect","accRect","getElementRects","getOffsetParentFn","getDimensionsFn","getDimensions","getClientRects","autoUpdate","update","ancestorScroll","ancestorResize","elementResize","ResizeObserver","layoutShift","IntersectionObserver","animationFrame","referenceEl","ancestors","forEach","cleanupIo","onMove","timeoutId","io","cleanup","disconnect","refresh","skip","threshold","rootMargin","isFirstUpdate","handleObserve","entries","ratio","intersectionRatio","observe","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","unobserve","cancelAnimationFrame","requestAnimationFrame","prevRefRect","frameLoop","nextRefRect","Map","mergedOptions","platformWithCache","config","middleware","validMiddleware","Boolean","statefulPlacement","resetCount","nextX","nextY","computePosition","createDOMRect","DOMRect","toJSON","getAnchorElement","getAnchorRect","anchor","anchorRect","getDOMRect","isValidPlacement","flip2","roundByDPR","dpr","devicePixelRatio","getOffsetMiddleware","arrowOffset","finalGutter","gutter","shift","getFlipMiddleware","overflowPadding","getShiftMiddleware","slide","overlap","limiter","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","rawOffset","computedOffset","len","limitMin","limitMax","_middlewareData$offse","_middlewareData$offse2","isOriginSide","getSizeMiddleware","availableWidth","availableHeight","wrapper","referenceWidth","setProperty","sameWidth","fitViewport","maxWidth","maxHeight","isYAxis","heightSide","widthSide","overflowAvailableHeight","overflowAvailableWidth","noShift","maximumClippingWidth","maximumClippingHeight","xMin","xMax","yMin","yMax","nextDimensions","getArrowMiddleware","arrowPadding","arrowDimensions","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","shouldAddOffset","centerOffset","usePopover","modal","portal","preserveTabOrder","autoFocusOnShow","wrapperProps","fixed","shift2","updatePosition","context","useState","disclosureElement","contentElement","mounted","positioned","setPositioned","portalRef","domReady","getAnchorRectProp","updatePositionProp","hasCustomUpdatePosition","isConnected","updatePosition2","pos","assign","arrowX","arrowY","dir","cancelAutoUpdate","applyZIndex","zIndex","raf","jsx","ref","children","preserveTabOrderAnchor","htmlProps","usePopoverContext","usePopoverProviderContext","PopoverContextProvider","PopoverScopedContextProvider","useHovercardProviderContext","HovercardContextProvider","HovercardScopedContextProvider","useHovercardStoreProps","createTooltipStore","hovercard","timeout","showTimeout","hideTimeout","setAutoFocusOnShow","createHovercardStore","skipTimeout","tooltip","useTooltipStore","useTooltipStoreProps","usePopoverStoreProps","useHovercardAnchor","showOnHover","disabled","showTimeoutRef","useRef","useEffect","current","onMouseMoveProp","onMouseMove","showOnHoverProp","isMouseMoving","defaultPrevented","currentTarget","setDisclosureElement","showHovercard","show","queueMicrotask","timeoutMs","useCallback","globalStore","activeStore","useTooltipAnchor","canShowOnHoverRef","hide","id","onMouseEnterProp","onMouseEnter","onFocusVisibleProp","onFocusVisible","onBlurProp","onBlur","contentId","_a2","TooltipAnchor","POPOVER_ARROW_PATH","defaultSize","halfDefaultSize","rotateMap","usePopoverArrow","size","setStyle","useComputedStyle","fill","getPropertyValue","stroke","borderWidth","strokeWidth","useMemo","viewBox","jsxs","fontSize","pointerEvents","useTooltipArrow","TooltipArrow","getEventPoint","clientX","isPointInPolygon","point","polygon","inside","l","j","xi","yi","xj","yj","vy","where","getElementPolygon","enterPoint","getEnterPointPlacement","isMovingOnHovercard","card","nested","card2","NestedHovercardContext","createContext","useHovercard","hideOnEscape","hideOnHoverOutside","disablePointerEventsOnApproach","nestedHovercards","setNestedHovercards","hideTimeoutRef","enterPointRef","mayHideOnHoverOutside","hideOnHoverOutsideProp","mayDisablePointerEvents","disablePointerEventsProp","open","composedPath","currentPoint","disableEvent","openRef","registerOnParent","registerNestedHovercard","prevElements","parentUnregister","item","Provider","autoFocusOnHide","setAutoFocusOnHide","onFocusProp","onFocus","finalFocusRef","finalFocus","useAutoFocusOnHide","useTooltip","hideOnInteractOutside","role","dataset","Tooltip"],"sourceRoot":""}