{"version":3,"file":"7808.bfd72543.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/BRS7GKWU.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/@ariakit/react-core/esm/__chunks/YMV43K4F.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/6YZEXKNV.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/E5E7G32I.js","webpack://@finviz/website/../node_modules/@ariakit/react-core/esm/__chunks/FWINX72I.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/core/esm/tooltip/tooltip-store.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/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/tooltip/tooltip-provider.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  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  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","\"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","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  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  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  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  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  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  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\";\nimport {\n  TooltipContextProvider\n} from \"../__chunks/3OMHZVJD.js\";\nimport \"../__chunks/TWDHCE7Y.js\";\nimport \"../__chunks/TE637IA7.js\";\nimport \"../__chunks/XXVAHUAO.js\";\nimport \"../__chunks/J55AVALY.js\";\nimport \"../__chunks/5M6RSQEC.js\";\nimport {\n  useTooltipStore\n} from \"../__chunks/WKII7I2E.js\";\nimport \"../__chunks/E5E7G32I.js\";\nimport \"../__chunks/XWCFCD3Q.js\";\nimport \"../__chunks/I62TROYO.js\";\nimport \"../__chunks/HZJ2XALY.js\";\nimport \"../__chunks/EKQEJRUF.js\";\nimport \"../__chunks/6O5OEQGF.js\";\nimport \"../__chunks/XM66DUTO.js\";\nimport \"../__chunks/4R3V3JGP.js\";\n\n// src/tooltip/tooltip-provider.tsx\nimport { jsx } from \"react/jsx-runtime\";\nfunction TooltipProvider(props = {}) {\n  const store = useTooltipStore(props);\n  return /* @__PURE__ */ jsx(TooltipContextProvider, { value: store, children: props.children });\n}\nexport {\n  TooltipProvider\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","createHovercardStore","props","_a","syncState","store","getState","popover","placement","timeout","initialState","showTimeout","hideTimeout","autoFocusOnShow","hovercard","setAutoFocusOnShow","setState","createPopoverStore","_b","otherPopover","dialog","currentPlacement","anchorElement","popoverElement","arrowElement","rendered","Symbol","setAnchorElement","element","setPopoverElement","setArrowElement","render","ctx","useTooltipContext","useContext","useTooltipProviderContext","useScopedContext","useProviderContext","TooltipContextProvider","ContextProvider","TooltipScopedContextProvider","ScopedContextProvider","getEventPoint","clientX","isPointInPolygon","point","polygon","x","y","inside","l","j","xi","yi","xj","yj","vy","where","getElementPolygon","enterPoint","rect","getBoundingClientRect","top","right","bottom","left","getEnterPointPlacement","push","isMovingOnHovercard","card","anchor","nested","card2","NestedHovercardContext","createContext","useHovercard","modal","portal","hideOnEscape","hideOnHoverOutside","disablePointerEventsOnApproach","context","ref","useRef","nestedHovercards","setNestedHovercards","useState","hideTimeoutRef","enterPointRef","portalRef","domReady","mayHideOnHoverOutside","hideOnHoverOutsideProp","mayDisablePointerEvents","disablePointerEventsProp","open","mounted","useEffect","current","composedPath","currentPoint","hide","disableEvent","openRef","registerOnParent","registerNestedHovercard","useCallback","prevElements","parentUnregister","item","jsx","children","Provider","autoFocusOnHide","setAutoFocusOnHide","onFocusProp","onFocus","defaultPrevented","finalFocusRef","state","finalFocus","useAutoFocusOnHide","requestAnimationFrame","htmlProps","round","floor","createCoords","v","oppositeSideMap","oppositeAlignmentMap","start","end","clamp","param","split","getOppositeAxis","axis","getAxisLength","includes","getAlignmentAxis","alignment","getOppositePlacement","side","padding","expandPaddingObject","width","height","computeCoordsFromPlacement","_ref","rtl","reference","floating","sideAxis","alignmentAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","async","detectOverflow","_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","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","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","prevRefRect","frameLoop","nextRefRect","Map","mergedOptions","platformWithCache","config","middleware","validMiddleware","Boolean","statefulPlacement","resetCount","nextX","nextY","computePosition","createDOMRect","DOMRect","toJSON","getAnchorElement","getAnchorRect","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","preserveTabOrder","wrapperProps","fixed","shift2","updatePosition","disclosureElement","contentElement","positioned","setPositioned","getAnchorRectProp","updatePositionProp","hasCustomUpdatePosition","isConnected","updatePosition2","pos","assign","arrowX","arrowY","dir","cancelAutoUpdate","applyZIndex","zIndex","raf","preserveTabOrderAnchor","Popover","useHovercardStoreProps","useHovercardAnchor","showOnHover","disabled","showTimeoutRef","onMouseMoveProp","onMouseMove","showOnHoverProp","isMouseMoving","currentTarget","setDisclosureElement","showHovercard","show","queueMicrotask","timeoutMs","usePopoverContext","usePopoverProviderContext","PopoverContextProvider","PopoverScopedContextProvider","useHovercardProviderContext","HovercardContextProvider","HovercardScopedContextProvider","createTooltipStore","skipTimeout","tooltip","useTooltipStore","useTooltipStoreProps","usePopoverStoreProps","usePopoverStore","globalStore","activeStore","useTooltipAnchor","canShowOnHoverRef","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","TooltipProvider","useTooltip","hideOnInteractOutside","role","dataset","Tooltip"],"sourceRoot":""}