{"version":3,"file":"floating-ui.dom.mjs","sources":["../../../../../node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs"],"sourcesContent":["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';\n\nfunction getWindow(node) {\n var _node$ownerDocument;\n return ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\n\nfunction getComputedStyle$1(element) {\n return getWindow(element).getComputedStyle(element);\n}\n\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\n\nfunction getCssDimensions(element) {\n const css = getComputedStyle$1(element);\n let width = parseFloat(css.width);\n let height = parseFloat(css.height);\n const offsetWidth = element.offsetWidth;\n const offsetHeight = element.offsetHeight;\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 fallback: shouldFallback\n };\n}\n\nfunction getNodeName(node) {\n return isNode(node) ? (node.nodeName || '').toLowerCase() : '';\n}\n\nlet uaString;\nfunction getUAString() {\n if (uaString) {\n return uaString;\n }\n const uaData = navigator.userAgentData;\n if (uaData && Array.isArray(uaData.brands)) {\n uaString = uaData.brands.map(item => item.brand + \"/\" + item.version).join(' ');\n return uaString;\n }\n return navigator.userAgent;\n}\n\nfunction isHTMLElement(value) {\n return value instanceof getWindow(value).HTMLElement;\n}\nfunction isElement(value) {\n return value instanceof getWindow(value).Element;\n}\nfunction isNode(value) {\n return value instanceof getWindow(value).Node;\n}\nfunction isShadowRoot(node) {\n // Browsers without `ShadowRoot` support.\n if (typeof ShadowRoot === 'undefined') {\n return false;\n }\n const OwnElement = getWindow(node).ShadowRoot;\n return node instanceof OwnElement || node instanceof ShadowRoot;\n}\nfunction isOverflowElement(element) {\n const {\n overflow,\n overflowX,\n overflowY,\n display\n } = getComputedStyle$1(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 // TODO: Try to use feature detection here instead.\n const isFirefox = /firefox/i.test(getUAString());\n const css = getComputedStyle$1(element);\n const backdropFilter = css.backdropFilter || css.WebkitBackdropFilter;\n\n // This is non-exhaustive but covers the most common CSS properties that\n // create a containing block.\n // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n return css.transform !== 'none' || css.perspective !== 'none' || (backdropFilter ? backdropFilter !== 'none' : false) || isFirefox && css.willChange === 'filter' || isFirefox && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective'].some(value => css.willChange.includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => {\n // Add type check for old browsers.\n const contain = css.contain;\n return contain != null ? contain.includes(value) : false;\n });\n}\n\n/**\n * Determines whether or not `.getBoundingClientRect()` is affected by visual\n * viewport offsets. In Safari, the `x`/`y` offsets are values relative to the\n * visual viewport, while in other engines, they are values relative to the\n * layout viewport.\n */\nfunction isClientRectVisualViewportBased() {\n // TODO: Try to use feature detection here instead. Feature detection for\n // this can fail in various ways, making the userAgent check the most\n // reliable:\n // • Always-visible scrollbar or not\n // • Width of \n\n // Is Safari.\n return /^((?!chrome|android).)*safari/i.test(getUAString());\n}\nfunction isLastTraversableNode(node) {\n return ['html', 'body', '#document'].includes(getNodeName(node));\n}\n\nfunction unwrapElement(element) {\n return !isElement(element) ? element.contextElement : element;\n}\n\nconst FALLBACK_SCALE = {\n x: 1,\n y: 1\n};\nfunction getScale(element) {\n const domElement = unwrapElement(element);\n if (!isHTMLElement(domElement)) {\n return FALLBACK_SCALE;\n }\n const rect = domElement.getBoundingClientRect();\n const {\n width,\n height,\n fallback\n } = getCssDimensions(domElement);\n let x = (fallback ? round(rect.width) : rect.width) / width;\n let y = (fallback ? 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\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n var _win$visualViewport, _win$visualViewport2;\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 = FALLBACK_SCALE;\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 win = domElement ? getWindow(domElement) : window;\n const addVisualOffsets = isClientRectVisualViewportBased() && isFixedStrategy;\n let x = (clientRect.left + (addVisualOffsets ? ((_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) || 0 : 0)) / scale.x;\n let y = (clientRect.top + (addVisualOffsets ? ((_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) || 0 : 0)) / 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 iframeRect.x += (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n iframeRect.y += (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 += iframeRect.x;\n y += iframeRect.y;\n currentIFrame = getWindow(currentIFrame).frameElement;\n }\n }\n return rectToClientRect({\n width,\n height,\n x,\n y\n });\n}\n\nfunction getDocumentElement(node) {\n return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;\n}\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}\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 = {\n x: 1,\n y: 1\n };\n const offsets = {\n x: 0,\n y: 0\n };\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 getWindowScrollBarX(element) {\n // If 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 `` and `` rect bounds if horizontally scrollable.\nfunction getDocumentRect(element) {\n const html = getDocumentElement(element);\n const scroll = getNodeScroll(element);\n const body = element.ownerDocument.body;\n const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);\n const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);\n let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n const y = -scroll.scrollTop;\n if (getComputedStyle$1(body).direction === 'rtl') {\n x += max(html.clientWidth, body.clientWidth) - width;\n }\n return {\n width,\n height,\n x,\n y\n };\n}\n\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}\n\nfunction getNearestOverflowAncestor(node) {\n const parentNode = getParentNode(node);\n if (isLastTraversableNode(parentNode)) {\n // `getParentNode` will never return a `Document` due to the fallback\n // check, so it's either the or element.\n return parentNode.ownerDocument.body;\n }\n if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n return parentNode;\n }\n return getNearestOverflowAncestor(parentNode);\n}\n\nfunction getOverflowAncestors(node, list) {\n var _node$ownerDocument;\n if (list === void 0) {\n list = [];\n }\n const scrollableAncestor = getNearestOverflowAncestor(node);\n const isBody = scrollableAncestor === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body);\n const win = getWindow(scrollableAncestor);\n if (isBody) {\n return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []);\n }\n return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor));\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 = isClientRectVisualViewportBased();\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) : {\n x: 1,\n y: 1\n };\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 mutableRect = {\n ...clippingAncestor\n };\n if (isClientRectVisualViewportBased()) {\n var _win$visualViewport, _win$visualViewport2;\n const win = getWindow(element);\n mutableRect.x -= ((_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) || 0;\n mutableRect.y -= ((_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) || 0;\n }\n rect = mutableRect;\n }\n return rectToClientRect(rect);\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).filter(el => isElement(el) && getNodeName(el) !== 'body');\n let currentContainingBlockComputedStyle = null;\n const elementIsFixed = getComputedStyle$1(element).position === 'fixed';\n let currentNode = elementIsFixed ? getParentNode(element) : element;\n\n // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {\n const computedStyle = getComputedStyle$1(currentNode);\n const containingBlock = isContainingBlock(currentNode);\n const shouldIgnoreCurrentNode = computedStyle.position === 'fixed';\n if (shouldIgnoreCurrentNode) {\n currentContainingBlockComputedStyle = null;\n } else {\n const shouldDropCurrentNode = elementIsFixed ? !containingBlock && !currentContainingBlockComputedStyle : !containingBlock && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position);\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 }\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 if (isHTMLElement(element)) {\n return getCssDimensions(element);\n }\n return element.getBoundingClientRect();\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {\n return null;\n }\n if (polyfill) {\n return polyfill(element);\n }\n return element.offsetParent;\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}\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$1(offsetParent).position === 'static') {\n offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n }\n if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {\n return window;\n }\n return offsetParent || getContainingBlock(element) || window;\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n const isOffsetParentAnElement = isHTMLElement(offsetParent);\n const documentElement = getDocumentElement(offsetParent);\n const rect = getBoundingClientRect(element, true, strategy === 'fixed', offsetParent);\n let scroll = {\n scrollLeft: 0,\n scrollTop: 0\n };\n const offsets = {\n x: 0,\n y: 0\n };\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, true);\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\nconst platform = {\n getClippingRect,\n convertOffsetParentRelativeRectToViewportRelativeRect,\n isElement,\n getDimensions,\n getOffsetParent,\n getDocumentElement,\n getScale,\n async getElementRects(_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 getClientRects: element => Array.from(element.getClientRects()),\n isRTL: element => getComputedStyle$1(element).direction === 'rtl'\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: _ancestorScroll = true,\n ancestorResize = true,\n elementResize = true,\n animationFrame = false\n } = options;\n const ancestorScroll = _ancestorScroll && !animationFrame;\n const ancestors = ancestorScroll || ancestorResize ? [...(isElement(reference) ? getOverflowAncestors(reference) : reference.contextElement ? getOverflowAncestors(reference.contextElement) : []), ...getOverflowAncestors(floating)] : [];\n ancestors.forEach(ancestor => {\n ancestorScroll && ancestor.addEventListener('scroll', update, {\n passive: true\n });\n ancestorResize && ancestor.addEventListener('resize', update);\n });\n let observer = null;\n if (elementResize) {\n let initialUpdate = true;\n observer = new ResizeObserver(() => {\n if (!initialUpdate) {\n update();\n }\n initialUpdate = false;\n });\n isElement(reference) && !animationFrame && observer.observe(reference);\n if (!isElement(reference) && reference.contextElement && !animationFrame) {\n observer.observe(reference.contextElement);\n }\n observer.observe(floating);\n }\n let frameId;\n let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n if (animationFrame) {\n frameLoop();\n }\n function frameLoop() {\n const nextRefRect = getBoundingClientRect(reference);\n if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n update();\n }\n prevRefRect = nextRefRect;\n frameId = requestAnimationFrame(frameLoop);\n }\n update();\n return () => {\n var _observer;\n ancestors.forEach(ancestor => {\n ancestorScroll && ancestor.removeEventListener('scroll', update);\n ancestorResize && ancestor.removeEventListener('resize', update);\n });\n (_observer = observer) == null ? void 0 : _observer.disconnect();\n observer = 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, getOverflowAncestors, platform };\n"],"names":["getWindow","node","_node$ownerDocument","ownerDocument","defaultView","window","getComputedStyle$1","element","getComputedStyle","min","Math","max","round","getCssDimensions","css","width","parseFloat","height","offsetWidth","offsetHeight","shouldFallback","fallback","getNodeName","isNode","nodeName","toLowerCase","uaString","getUAString","uaData","navigator","userAgentData","Array","isArray","brands","map","item","brand","version","join","userAgent","isHTMLElement","value","HTMLElement","isElement","Element","Node","isShadowRoot","ShadowRoot","isOverflowElement","overflow","overflowX","overflowY","display","test","includes","isTableElement","isContainingBlock","isFirefox","backdropFilter","WebkitBackdropFilter","transform","perspective","willChange","filter","some","contain","isClientRectVisualViewportBased","isLastTraversableNode","unwrapElement","contextElement","FALLBACK_SCALE","x","y","getScale","domElement","rect","getBoundingClientRect","Number","isFinite","includeScale","isFixedStrategy","offsetParent","_win$visualViewport","_win$visualViewport2","clientRect","scale","win","addVisualOffsets","left","visualViewport","offsetLeft","top","offsetTop","offsetWin","currentIFrame","frameElement","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","rectToClientRect","getDocumentElement","document","documentElement","getNodeScroll","scrollLeft","scrollTop","pageXOffset","pageYOffset","getWindowScrollBarX","getParentNode","result","assignedSlot","parentNode","host","getNearestOverflowAncestor","body","getOverflowAncestors","list","scrollableAncestor","isBody","concat","getClientRectFromClippingAncestor","clippingAncestor","strategy","getViewportRect","html","clientWidth","clientHeight","visualViewportBased","getDocumentRect","scroll","scrollWidth","scrollHeight","direction","getInnerBoundingClientRect","mutableRect","getTrueOffsetParent","polyfill","position","getOffsetParent","getContainingBlock","currentNode","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","platform","getClippingRect","_ref","boundary","rootBoundary","clippingAncestors","getClippingElementAncestors","cache","cachedResult","get","el","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","containingBlock","ancestor","set","this","_c","firstClippingAncestor","clippingRect","reduce","accRect","right","bottom","convertOffsetParentRelativeRectToViewportRelativeRect","getDimensions","getElementRects","reference","floating","getOffsetParentFn","getDimensionsFn","getClientRects","from","isRTL","autoUpdate","update","options","ancestorScroll","_ancestorScroll","ancestorResize","elementResize","animationFrame","ancestors","forEach","addEventListener","passive","frameId","observer","initialUpdate","ResizeObserver","observe","prevRefRect","frameLoop","nextRefRect","requestAnimationFrame","_observer","removeEventListener","disconnect","cancelAnimationFrame","computePosition","Map","mergedOptions","platformWithCache","computePosition$1"],"mappings":"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","x_google_ignoreList":[0]}