@oracle/oraclejet-preact 20.1.4 → 20.1.5

package/amd/useColorScheme-6cb3a3b7.js

@@ -0,0 +1,2 @@
+define(['exports', 'preact/hooks', './LayerHost-1a734852', 'preact/jsx-runtime', 'preact/compat'], (function(e,t,o,n,r){"use strict";e.useColorScheme=function(){return t.useContext(o.EnvironmentContext).colorScheme}}));
+//# sourceMappingURL=useColorScheme-6cb3a3b7.js.map

package/amd/useColorScheme-6cb3a3b7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useColorScheme-6cb3a3b7.js","sources":["../../src/hooks/UNSAFE_useColorScheme/useColorScheme.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\nimport { useContext } from 'preact/hooks';\nimport { EnvironmentContext } from '../../UNSAFE_Environment';\n\nexport function useColorScheme() {\n  return useContext(EnvironmentContext).colorScheme;\n}\n"],"names":["useContext","EnvironmentContext","colorScheme"],"mappings":"4JAWE,OAAOA,EAAUA,WAACC,sBAAoBC,WACxC"}

package/amd/useContextMenu-025b44ba.js

@@ -1,2 +1,2 @@
-define(['exports', 'preact/jsx-runtime', 'preact/hooks', './Menu-0c230049', './MenuItem-8456d6e2', 'preact', './logger-00b673c5', './LayerHost-0b288129', 'preact/compat', 'css!./TooltipContentStyles.styles.css', 'module', './hooks/UNSAFE_useTooltip/themes/redwood/TooltipContentVariants.css', './tooltipUtils-d855e8f2', 'css!./IconStyle.styles.css', './SelectMenuGroupContext-67f24a8f', './UNSAFE_Menu/themes/MenuItemStyles.css', './UNSAFE_Separator/themes/SeparatorStyles.css', 'css!./MenuSeparatorStyles.styles.css', 'module', './UNSAFE_Menu/themes/redwood/MenuSeparatorVariants.css', 'css!./MenuStyles.styles.css', './useContextMenuGesture-750ef2c6'], (function(e,t,s,n,o,r,u,c,a,i,l,f,m,p,M,x,d,h,C,S,y,b){"use strict";const g={isOpen:!1,initialFocus:"menu",placement:"bottom-start",offsetValue:0,anchorRef:{current:null}};function R({contextMenuConfig:e,contextMenuContext:o,rootRef:r,setMenuProps:u,onContextMenuDismissed:c,gestureRef:a,...i}){const l=s.useCallback((e=>{"dismissed"!==e.reason&&"itemAction"!==e.reason||(r.current?.focus({preventScroll:!0}),c?.(a.current)),u(g)}),[r,a,u,c]);return t.jsx(n.Menu,{...i,onClose:l,"aria-label":e.accessibleLabel,children:i.isOpen&&e.itemsRenderer(o)})}const A={mouse:{initialFocus:"menu",placement:"bottom-start",offsetValue:0},keyboard:{initialFocus:"firstItem",placement:"bottom-start",offsetValue:0},touch:{initialFocus:"menu",placement:"end",offsetValue:30}};e.ContextMenu=R,e.useContextMenu=function({onContextMenuHandler:e,contextMenuOptions:n,rootRef:o,contextMenuConfig:r,onContextMenuDismissed:u}){const[c,a]=s.useState(),[i,l]=s.useState(g),f=s.useRef(null),m=s.useCallback((({gesture:t,anchor:s,target:n})=>{f.current=t;const{context:r,...u}=e({gesture:t,target:n});let c;switch(u.type){case"offset":{const{offsetValue:e,isRtl:t,width:s}=u,n=o.current?.getBoundingClientRect();c={x:t?s+n.x-Math.abs(e.crossAxis):n.x+Math.abs(e.crossAxis),y:n.y+Math.abs(e.mainAxis)};break}case"element":c=u.elem;break;case"pointer":c=s}a(r),l({...A[t],anchorRef:{current:c},isOpen:!0})}),[e,o]),p=r&&t.jsx(R,{...i,onContextMenuDismissed:u,gestureRef:f,setMenuProps:l,rootRef:o,contextMenuConfig:r,contextMenuContext:c}),{triggerProps:M}=b.useContextMenuGesture(m,{...n,isTouchHoldReleaseGesture:!0});return{contextMenuProps:M,contextMenuContent:p}}}));
+define(['exports', 'preact/jsx-runtime', 'preact/hooks', './Menu-0c230049', './MenuItem-8456d6e2', 'preact', './logger-00b673c5', './LayerHost-1a734852', 'preact/compat', 'css!./TooltipContentStyles.styles.css', 'module', './hooks/UNSAFE_useTooltip/themes/redwood/TooltipContentVariants.css', './tooltipUtils-2f3b01e4', 'css!./IconStyle.styles.css', './SelectMenuGroupContext-67f24a8f', './UNSAFE_Menu/themes/MenuItemStyles.css', './UNSAFE_Separator/themes/SeparatorStyles.css', 'css!./MenuSeparatorStyles.styles.css', 'module', './UNSAFE_Menu/themes/redwood/MenuSeparatorVariants.css', 'css!./MenuStyles.styles.css', './useContextMenuGesture-750ef2c6'], (function(e,t,s,n,o,r,u,a,c,i,l,f,m,p,M,x,d,h,C,S,y,b){"use strict";const g={isOpen:!1,initialFocus:"menu",placement:"bottom-start",offsetValue:0,anchorRef:{current:null}};function R({contextMenuConfig:e,contextMenuContext:o,rootRef:r,setMenuProps:u,onContextMenuDismissed:a,gestureRef:c,...i}){const l=s.useCallback((e=>{"dismissed"!==e.reason&&"itemAction"!==e.reason||(r.current?.focus({preventScroll:!0}),a?.(c.current)),u(g)}),[r,c,u,a]);return t.jsx(n.Menu,{...i,onClose:l,"aria-label":e.accessibleLabel,children:i.isOpen&&e.itemsRenderer(o)})}const A={mouse:{initialFocus:"menu",placement:"bottom-start",offsetValue:0},keyboard:{initialFocus:"firstItem",placement:"bottom-start",offsetValue:0},touch:{initialFocus:"menu",placement:"end",offsetValue:30}};e.ContextMenu=R,e.useContextMenu=function({onContextMenuHandler:e,contextMenuOptions:n,rootRef:o,contextMenuConfig:r,onContextMenuDismissed:u}){const[a,c]=s.useState(),[i,l]=s.useState(g),f=s.useRef(null),m=s.useCallback((({gesture:t,anchor:s,target:n})=>{f.current=t;const{context:r,...u}=e({gesture:t,target:n});let a;switch(u.type){case"offset":{const{offsetValue:e,isRtl:t,width:s}=u,n=o.current?.getBoundingClientRect();a={x:t?s+n.x-Math.abs(e.crossAxis):n.x+Math.abs(e.crossAxis),y:n.y+Math.abs(e.mainAxis)};break}case"element":a=u.elem;break;case"pointer":a=s}c(r),l({...A[t],anchorRef:{current:a},isOpen:!0})}),[e,o]),p=r&&t.jsx(R,{...i,onContextMenuDismissed:u,gestureRef:f,setMenuProps:l,rootRef:o,contextMenuConfig:r,contextMenuContext:a}),{triggerProps:M}=b.useContextMenuGesture(m,{...n,isTouchHoldReleaseGesture:!0});return{contextMenuProps:M,contextMenuContent:p}}}));
 //# sourceMappingURL=useContextMenu-025b44ba.js.map

package/amd/useCssVars-d0c0bfa2.js

@@ -0,0 +1,2 @@
+define(['exports', 'preact/jsx-runtime', 'preact/hooks', './useUser-e0677e8d', './useTheme-59bafcbb', './useColorScheme-6cb3a3b7', './useScale-404175fb'], (function(e,s,r,t,o,c,n){"use strict";e.useCssVars=function(e){const u=r.useRef(null),[a,f]=r.useState({}),{forcedColors:l}=t.useUser(),{name:i}=o.useTheme(),d=n.useScale(),p=c.useColorScheme(),h=e.reduce(((e,s)=>(s.cssProp&&(e[s.cssProp]=s.tokenVar),e)),{}),m=s.jsx("div",{ref:u,style:{display:"none",...h}});return r.useLayoutEffect((()=>{if(!u.current)return;const s=window.getComputedStyle(u.current),r={};e.forEach((e=>{const t=e.cssProp||function(e){const s=e.match(/var\((--[a-zA-Z_0-9\-]+)\)/);return s&&s.length>1?s[1]:""}(e.tokenVar);r[e.key]=s.getPropertyValue(t)})),f(r)}),[l,i,p,d,e]),{resolvedVars:a,cssContent:m}}}));
+//# sourceMappingURL=useCssVars-d0c0bfa2.js.map

package/amd/useCssVars-d0c0bfa2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCssVars-d0c0bfa2.js","sources":["../../src/hooks/PRIVATE_useCssVars/useCssVars.tsx"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\n\nimport { useLayoutEffect, useRef, useState } from 'preact/hooks';\nimport { useUser } from '../UNSAFE_useUser';\nimport { useTheme } from '../UNSAFE_useTheme';\nimport { useColorScheme } from '../UNSAFE_useColorScheme';\nimport { useScale } from '../UNSAFE_useScale';\n\nfunction getCssVarName(name: string) {\n  const rxp = name.match(/var\\((--[a-zA-Z_0-9\\-]+)\\)/);\n  return rxp && rxp.length > 1 ? rxp[1] : '';\n}\n\n/**\n * Hook to resolve the css vars.\n * @param vars\n * @param classes\n * @returns\n */\nexport function useCssVars(\n  vars: {\n    /**\n     * The token variable.\n     */\n    tokenVar: string;\n    /**\n     * The key of the resolved variable.\n     */\n    key: string;\n    /**\n     * The absolute used value of the token vars assigned to css expression cannot be computed through getComputedStyle if\n     * not assigned to a css property. This optional prop provides css property to assign the token var to in order to get\n     * actual used style.\n     */\n    cssProp?: string;\n  }[]\n) {\n  const cssDivRef = useRef<HTMLDivElement>(null);\n  const [resolvedVars, setResolvedVars] = useState<Record<string, any>>({});\n  const { forcedColors } = useUser();\n  const { name } = useTheme();\n  const scale = useScale();\n  const colorScheme = useColorScheme();\n\n  // A css token var (eg, --tokenVar_123xyz) that is assigned to a css expression like min(25px, 5rem) resolves to\n  // a string of the expression (resolved value) like \"min(25px, 5rem)\" and not absolute value (for eg 25px) (used value) when getComputedStyle is called.\n  // We have to assign the token var to a valid css property(like width: var(--tokenVar_123xyz)) in order to get actual used value in\n  // computed styles. https://developer.mozilla.org/en-US/docs/Web/CSS/used_value\n\n  // build a style obj with valid css property to apply to div\n  const style = vars.reduce((prev: Record<string, string>, current) => {\n    if (current.cssProp) {\n      prev[current.cssProp] = current.tokenVar;\n    }\n    return prev;\n  }, {});\n\n  const cssContent = <div ref={cssDivRef} style={{ display: 'none', ...style }}></div>;\n\n  useLayoutEffect(() => {\n    if (!cssDivRef.current) {\n      return;\n    }\n\n    const computedStyle = window.getComputedStyle(cssDivRef.current);\n    const resolved: Record<string, any> = {};\n    vars.forEach((value) => {\n      // use cssProp for token vars that resolve to expression\n      const cssVar = value.cssProp || getCssVarName(value.tokenVar);\n      resolved[value.key] = computedStyle.getPropertyValue(cssVar);\n    });\n    setResolvedVars(resolved);\n  }, [forcedColors, name, colorScheme, scale, vars]);\n\n  return {\n    resolvedVars,\n    cssContent\n  };\n}\n"],"names":["vars","cssDivRef","useRef","resolvedVars","setResolvedVars","useState","forcedColors","useUser","name","useTheme","scale","useScale","colorScheme","useColorScheme","style","reduce","prev","current","cssProp","tokenVar","cssContent","_jsx","jsx","ref","display","useLayoutEffect","computedStyle","window","getComputedStyle","resolved","forEach","value","cssVar","rxp","match","length","getCssVarName","key","getPropertyValue"],"mappings":"uMAyBM,SACJA,GAiBA,MAAMC,EAAYC,SAAuB,OAClCC,EAAcC,GAAmBC,EAAQA,SAAsB,CAAE,IAClEC,aAAEA,GAAiBC,EAAAA,WACnBC,KAAEA,GAASC,EAAAA,WACXC,EAAQC,EAAAA,WACRC,EAAcC,EAAAA,iBAQdC,EAAQd,EAAKe,QAAO,CAACC,EAA8BC,KACnDA,EAAQC,UACVF,EAAKC,EAAQC,SAAWD,EAAQE,UAE3BH,IACN,CAAE,GAECI,EAAaC,EAAAC,IAAA,MAAA,CAAKC,IAAKtB,EAAWa,MAAO,CAAEU,QAAS,UAAWV,KAiBrE,OAfAW,EAAAA,iBAAgB,KACd,IAAKxB,EAAUgB,QACb,OAGF,MAAMS,EAAgBC,OAAOC,iBAAiB3B,EAAUgB,SAClDY,EAAgC,CAAA,EACtC7B,EAAK8B,SAASC,IAEZ,MAAMC,EAASD,EAAMb,SA5D3B,SAAuBV,GACrB,MAAMyB,EAAMzB,EAAK0B,MAAM,8BACvB,OAAOD,GAAOA,EAAIE,OAAS,EAAIF,EAAI,GAAK,EAC1C,CAyDsCG,CAAcL,EAAMZ,UACpDU,EAASE,EAAMM,KAAOX,EAAcY,iBAAiBN,EAAO,IAE9D5B,EAAgByB,EAAS,GACxB,CAACvB,EAAcE,EAAMI,EAAaF,EAAOV,IAErC,CACLG,eACAiB,aAEJ"}

package/amd/useCurrentBgColor-3044b50a.js

@@ -0,0 +1,2 @@
+define(['exports', 'preact/hooks', './LayerHost-1a734852', 'preact/jsx-runtime', 'preact/compat'], (function(t,e,r,n,o){"use strict";t.useCurrentBgColor=function(){return e.useContext(r.EnvironmentContext).currentBgColor}}));
+//# sourceMappingURL=useCurrentBgColor-3044b50a.js.map

package/amd/useCurrentBgColor-3044b50a.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCurrentBgColor-3044b50a.js","sources":["../../src/hooks/UNSAFE_useCurrentBgColor/useCurrentBgColor.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\nimport { useContext } from 'preact/hooks';\nimport { EnvironmentContext } from '../../UNSAFE_Environment';\n\nexport function useCurrentBgColor() {\n  return useContext(EnvironmentContext).currentBgColor;\n}\n"],"names":["useContext","EnvironmentContext","currentBgColor"],"mappings":"+JAWE,OAAOA,EAAUA,WAACC,sBAAoBC,cACxC"}

package/amd/useCurrentKey-05038cac.js

@@ -0,0 +1,2 @@
+define(['exports', 'preact/hooks', './keys-4755c121', './useUser-e0677e8d'], (function(e,t,r,s){"use strict";e.useCurrentKey=function(e,n,i,o,c,u,l,y,a,f){const{direction:K}=s.useUser(),k=t.useCallback(((e,t)=>f?f(e,t):e===t),[f]),d=t.useCallback((e=>{if(a&&r.isKeyDefined(y&&!i)){const t="rtl"===K,s={ArrowUp:o,ArrowDown:c,ArrowLeft:t?l:u,ArrowRight:t?u:l};if(Object.keys(s).includes(e.key)&&(n||!e.shiftKey)&&!e.metaKey&&!e.ctrlKey){const t=s[e.key]?.();r.isKeyDefined(t)&&!k(y,t)&&a({value:t}),e.preventDefault()}}}),[y,i,a,o,c,u,l,k,n,K]),p=t.useCallback((t=>{if(a&&(n||!t.shiftKey)){const s=e(t.target);r.isKeyDefined(s)&&!k(y,s)&&a({value:s})}}),[y,n,e,a,k]);return{currentKeyProps:null==a?{}:{onClickCapture:p,onKeyDown:d}}}}));
+//# sourceMappingURL=useCurrentKey-05038cac.js.map

package/amd/useCurrentKey-05038cac.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCurrentKey-05038cac.js","sources":["../../src/hooks/PRIVATE_useCurrentKey/useCurrentKey.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\nimport { useCallback } from 'preact/hooks';\nimport { isKeyDefined } from '../../utils/UNSAFE_keys';\nimport { CurrentKeyDetail } from '../../UNSAFE_Collection';\nimport { useUser } from '../UNSAFE_useUser';\n\n/**\n * Hook for handling current key update due to user interaction including keyboard navigation.\n * This can be reuse by all Collection components.\n *\n * @param keyExtractor function to extract the key based on the provided element\n * @param allowShiftKey if set to false, then pressing arrow key while shift key is down will not change the current key\n * @param isTabbable whether the component is currently in tabbable mode\n * @param getVerticalPrevKey function to get the previous key in the vertical direction based on the current key\n * @param getVerticalNextKey function to get the next key in the vertical direction based on the current key\n * @param getHorizontalPrevKey function to get the previous key in the horizontal direction based on the current key\n * @param getHorizontalNextKey function to get the next key based on the current key\n * @param currentKey the current key\n * @param onCurrentChange function to invoke if the current key has changed\n * @param keyComparator an optional function to compare keys, otherwise === is used\n * @returns\n */\nexport function useCurrentKey<K>(\n  keyExtractor: (element: HTMLElement) => K | null,\n  allowShiftKey: boolean,\n  isTabbable: boolean,\n  getVerticalPrevKey?: () => K | null,\n  getVerticalNextKey?: () => K | null,\n  getHorizontalPrevKey?: () => K | null,\n  getHorizontalNextKey?: () => K | null,\n  currentKey?: K,\n  onChange?: (detail: CurrentKeyDetail<K>) => void,\n  keyComparator?: (key1: K, key2: K) => boolean\n) {\n  const { direction } = useUser();\n\n  const keyEquals = useCallback(\n    (key1: K, key2: K) => {\n      if (keyComparator) {\n        return keyComparator(key1, key2);\n      }\n      return key1 === key2;\n    },\n    [keyComparator]\n  );\n\n  const onKeyDown = useCallback(\n    (event: KeyboardEvent) => {\n      if (onChange && isKeyDefined(currentKey && !isTabbable)) {\n        const isRtl = direction === 'rtl';\n        const keyHandlers: Record<string, (() => K | null) | undefined> = {\n          ArrowUp: getVerticalPrevKey,\n          ArrowDown: getVerticalNextKey,\n          ArrowLeft: isRtl ? getHorizontalNextKey : getHorizontalPrevKey,\n          ArrowRight: isRtl ? getHorizontalPrevKey : getHorizontalNextKey\n        };\n\n        // should not update currentKey during keyboard reordering\n        if (\n          Object.keys(keyHandlers).includes(event.key) &&\n          (allowShiftKey || !event.shiftKey) &&\n          !event.metaKey &&\n          !event.ctrlKey\n        ) {\n          const newKey = keyHandlers[event.key]?.();\n          if (isKeyDefined(newKey) && !keyEquals(currentKey as K, newKey as K)) {\n            onChange({ value: newKey as K });\n          }\n          event.preventDefault();\n        }\n      }\n    },\n    [\n      currentKey,\n      isTabbable,\n      onChange,\n      getVerticalPrevKey,\n      getVerticalNextKey,\n      getHorizontalPrevKey,\n      getHorizontalNextKey,\n      keyEquals,\n      allowShiftKey,\n      direction\n    ]\n  );\n\n  const onClickCapture = useCallback(\n    (event: MouseEvent) => {\n      if (onChange && (allowShiftKey || !event.shiftKey)) {\n        const nextKey = keyExtractor(event.target as HTMLElement);\n        if (isKeyDefined(nextKey) && !keyEquals(currentKey as K, nextKey as K)) {\n          onChange({ value: nextKey as K });\n        }\n      }\n    },\n    [currentKey, allowShiftKey, keyExtractor, onChange, keyEquals]\n  );\n\n  const currentKeyProps = onChange == null ? {} : { onClickCapture, onKeyDown };\n  return { currentKeyProps };\n}\n"],"names":["keyExtractor","allowShiftKey","isTabbable","getVerticalPrevKey","getVerticalNextKey","getHorizontalPrevKey","getHorizontalNextKey","currentKey","onChange","keyComparator","direction","useUser","keyEquals","useCallback","key1","key2","onKeyDown","event","isKeyDefined","isRtl","keyHandlers","ArrowUp","ArrowDown","ArrowLeft","ArrowRight","Object","keys","includes","key","shiftKey","metaKey","ctrlKey","newKey","value","preventDefault","onClickCapture","nextKey","target","currentKeyProps"],"mappings":"yHA4BM,SACJA,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,GAEA,MAAMC,UAAEA,GAAcC,EAAAA,UAEhBC,EAAYC,EAAAA,aAChB,CAACC,EAASC,IACJN,EACKA,EAAcK,EAAMC,GAEtBD,IAASC,GAElB,CAACN,IAGGO,EAAYH,eACfI,IACC,GAAIT,GAAYU,EAAYA,aAACX,IAAeL,GAAa,CACvD,MAAMiB,EAAsB,QAAdT,EACRU,EAA4D,CAChEC,QAASlB,EACTmB,UAAWlB,EACXmB,UAAWJ,EAAQb,EAAuBD,EAC1CmB,WAAYL,EAAQd,EAAuBC,GAI7C,GACEmB,OAAOC,KAAKN,GAAaO,SAASV,EAAMW,OACvC3B,IAAkBgB,EAAMY,YACxBZ,EAAMa,UACNb,EAAMc,QACP,CACA,MAAMC,EAASZ,EAAYH,EAAMW,SAC7BV,EAAAA,aAAac,KAAYpB,EAAUL,EAAiByB,IACtDxB,EAAS,CAAEyB,MAAOD,IAEpBf,EAAMiB,gBACP,CACF,IAEH,CACE3B,EACAL,EACAM,EACAL,EACAC,EACAC,EACAC,EACAM,EACAX,EACAS,IAIEyB,EAAiBtB,eACpBI,IACC,GAAIT,IAAaP,IAAkBgB,EAAMY,UAAW,CAClD,MAAMO,EAAUpC,EAAaiB,EAAMoB,QAC/BnB,EAAAA,aAAakB,KAAaxB,EAAUL,EAAiB6B,IACvD5B,EAAS,CAAEyB,MAAOG,GAErB,IAEH,CAAC7B,EAAYN,EAAeD,EAAcQ,EAAUI,IAItD,MAAO,CAAE0B,gBAD2B,MAAZ9B,EAAmB,CAAE,EAAG,CAAE2B,iBAAgBnB,aAEpE"}

package/amd/useDatatip-a2c4bd6d.js

@@ -0,0 +1,2 @@
+define(['exports', 'preact/jsx-runtime', './Layer-64bf71ad', 'preact/compat', './LayerHost-1a734852', './Floating-e8ec1b0b', 'preact/hooks', './hooks/PRIVATE_useDatatip/themes/useDatatip.css', './useId-c9578d26', './datatipUtils-6846028e', './useVisHover-28319fef', './mergeProps-bcfa6a92', './classNames-08d99695'], (function(e,t,s,n,o,r,a,i,c,l,u,d,p){"use strict";e.useDatatip=function({content:e,placement:n="top-end-corner",offset:o,borderColor:A,defaultContainer:f="enabled",anchor:v,touchResponse:T,isDisabled:h}){const m=a.useRef(c.useId()),[b,x]=a.useState({x:0,y:0}),y=o||{mainAxis:l.DATATIP_OFFSET,crossAxis:-1*l.DATATIP_OFFSET},[E,P]=a.useState(!1),D=a.useRef(null),R=a.useRef(),B=()=>{R.current=setTimeout((()=>{P(!1)}),20)},F=u.useVisHover((e=>{x({x:e.clientX,y:e.clientY}),P(!0)}),((e,t)=>{"touch"!==e.pointerType&&e.eventPhase!==Event.AT_TARGET&&e.eventPhase!==Event.BUBBLING_PHASE||(x({x:e.clientX,y:e.clientY}),D.current=t,P(!0))}),B,T),I="element"===v?D:{current:b},L=E&&e&&!h?t.jsx(s.Layer,{children:t.jsx(r.Floating,{anchorRef:I,placement:n,offsetValue:y,flipOptions:{crossAxis:"pointer"===v,mainAxis:"pointer"===v},shiftOptions:{crossAxis:!0,mainAxis:!0},children:t.jsx("div",{role:"tooltip",id:m.current,className:p.classNames([i.styles.visDatatipStyle,"enabled"===f?i.styles.borderEnabled:void 0]),style:"enabled"===f?{borderColor:A}:void 0,onPointerEnter:()=>{clearTimeout(R.current)},onPointerLeave:B,children:e})})}):null;return{datatipContent:L,datatipProps:{"aria-describedby":null!==L?m.current:void 0,...d.mergeProps(F,{onKeyUp:e=>{"ArrowUp"!==e.code&&"ArrowDown"!==e.code&&"ArrowRight"!==e.code&&"ArrowLeft"!==e.code&&"Tab"!==e.code||P(!0)},onKeyDown:e=>{"Escape"===e.code&&(e.preventDefault(),P(!1))},onFocus:e=>{e.eventPhase!==Event.AT_TARGET&&e.eventPhase!==Event.BUBBLING_PHASE||(D.current=e.target,P(!0))},onBlur:()=>{P(!1)}})}}}}));
+//# sourceMappingURL=useDatatip-a2c4bd6d.js.map

package/amd/useDatatip-a2c4bd6d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDatatip-a2c4bd6d.js","sources":["../../src/hooks/PRIVATE_useDatatip/useDatatip.tsx"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * Licensed under The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\n\nimport { ComponentChildren } from 'preact';\nimport { Layer } from '#UNSAFE_Layer';\nimport { Floating, Placement } from '#UNSAFE_Floating';\nimport { useRef, useState } from 'preact/hooks';\nimport { styles } from './themes/useDatatip.css';\nimport { useId } from '#hooks/UNSAFE_useId';\nimport { Property } from 'csstype';\nimport { DATATIP_OFFSET } from '#utils/UNSAFE_visUtils/datatipUtils';\nimport { useVisHover } from '#hooks/PRIVATE_useVisHover';\nimport { mergeProps } from '#utils/UNSAFE_mergeProps';\nimport { classNames } from '#utils/UNSAFE_classNames';\nexport type { Dimension } from '#utils/UNSAFE_visTypes/common';\n\ntype DatatipProps = {\n  /**\n   * The datatip content.\n   */\n  content?: ComponentChildren;\n\n  /**\n   * Whether the datatip is anchored to pointer or element.\n   *\n   */\n  anchor: 'element' | 'pointer';\n\n  /**\n   * The offset from the anchor element or pointer.\n   */\n  offset?: {\n    mainAxis?: number;\n    crossAxis?: number;\n  };\n\n  /**\n   * The border color of the datatip.\n   */\n  borderColor?: Property.BorderColor;\n\n  /**\n   * The placement of datatip from anchor point.\n   */\n  placement?: Placement;\n\n  /**\n   * The touch response value.\n   */\n  touchResponse: 'touchStart' | 'touchHold';\n\n  /**\n   * Whether datatip is disabled\n   */\n  isDisabled?: boolean;\n\n  /**\n   * Whether the datatip default border is enabled.\n   */\n  defaultContainer?: 'enabled' | 'disabled';\n};\n\n/**\n * The hook to support custom datatip in visualization components.\n */\nexport function useDatatip({\n  content,\n  placement = 'top-end-corner',\n  offset,\n  borderColor,\n  defaultContainer = 'enabled',\n  anchor,\n  touchResponse,\n  isDisabled\n}: DatatipProps) {\n  const uniqueIdRef = useRef<string>(useId());\n  const [coords, setCoords] = useState({ x: 0, y: 0 });\n  const offsetValue = offset || { mainAxis: DATATIP_OFFSET, crossAxis: -1 * DATATIP_OFFSET };\n  const [isVisible, setIsVisible] = useState(false);\n\n  const targetRef = useRef<HTMLElement | null>(null);\n  const toggleTimeoutRef = useRef<ReturnType<typeof setTimeout>>();\n\n  const onHover = (event: PointerEvent) => {\n    setCoords({ x: event.clientX, y: event.clientY });\n    setIsVisible(true);\n  };\n\n  const onHoverEnter = (event: PointerEvent, currentTarget: HTMLElement) => {\n    if (\n      event.pointerType === 'touch' ||\n      event.eventPhase === Event.AT_TARGET ||\n      event.eventPhase === Event.BUBBLING_PHASE\n    ) {\n      setCoords({ x: event.clientX, y: event.clientY });\n      targetRef.current = currentTarget;\n      setIsVisible(true);\n    }\n  };\n\n  const onHoverLeave = () => {\n    toggleTimeoutRef.current = setTimeout(() => {\n      setIsVisible(false);\n    }, 20);\n  };\n\n  const hoverHandlers = useVisHover(onHover, onHoverEnter, onHoverLeave, touchResponse);\n\n  const onFocus = (event: FocusEvent) => {\n    if (event.eventPhase === Event.AT_TARGET || event.eventPhase === Event.BUBBLING_PHASE) {\n      targetRef.current = event.target as HTMLElement;\n      setIsVisible(true);\n    }\n  };\n\n  const onBlur = () => {\n    setIsVisible(false);\n  };\n\n  const onContentPointerEnter = () => {\n    clearTimeout(toggleTimeoutRef.current);\n  };\n\n  const onKeyUp = (event: KeyboardEvent) => {\n    if (\n      event.code === 'ArrowUp' ||\n      event.code === 'ArrowDown' ||\n      event.code === 'ArrowRight' ||\n      event.code === 'ArrowLeft' ||\n      event.code === 'Tab'\n    ) {\n      setIsVisible(true);\n    }\n  };\n\n  const onKeyDown = (event: KeyboardEvent) => {\n    if (event.code === 'Escape') {\n      event.preventDefault();\n      setIsVisible(false);\n    }\n  };\n\n  const anchorRef = anchor === 'element' ? targetRef : { current: coords };\n  const datatipContent =\n    isVisible && !!content && !isDisabled ? (\n      <Layer>\n        <Floating\n          anchorRef={anchorRef}\n          placement={placement}\n          offsetValue={offsetValue}\n          flipOptions={{\n            crossAxis: anchor === 'pointer' ? true : false,\n            mainAxis: anchor === 'pointer' ? true : false\n          }}\n          shiftOptions={{ crossAxis: true, mainAxis: true }}>\n          <div\n            role=\"tooltip\"\n            id={uniqueIdRef.current}\n            className={classNames([\n              styles.visDatatipStyle,\n              defaultContainer === 'enabled' ? styles.borderEnabled : undefined\n            ])}\n            style={defaultContainer === 'enabled' ? { borderColor } : undefined}\n            onPointerEnter={onContentPointerEnter}\n            onPointerLeave={onHoverLeave}>\n            {content}\n          </div>\n        </Floating>\n      </Layer>\n    ) : null;\n\n  return {\n    datatipContent,\n    datatipProps: {\n      'aria-describedby': datatipContent !== null ? uniqueIdRef.current : undefined,\n      ...mergeProps(hoverHandlers, {\n        onKeyUp,\n        onKeyDown,\n        onFocus,\n        onBlur\n      })\n    }\n  };\n}\n"],"names":["content","placement","offset","borderColor","defaultContainer","anchor","touchResponse","isDisabled","uniqueIdRef","useRef","useId","coords","setCoords","useState","x","y","offsetValue","mainAxis","DATATIP_OFFSET","crossAxis","isVisible","setIsVisible","targetRef","toggleTimeoutRef","onHoverLeave","current","setTimeout","hoverHandlers","useVisHover","event","clientX","clientY","currentTarget","pointerType","eventPhase","Event","AT_TARGET","BUBBLING_PHASE","anchorRef","datatipContent","_jsx","Layer","children","Floating","flipOptions","shiftOptions","role","id","className","classNames","styles","visDatatipStyle","borderEnabled","undefined","style","onPointerEnter","clearTimeout","onPointerLeave","datatipProps","mergeProps","onKeyUp","code","onKeyDown","preventDefault","onFocus","target","onBlur"],"mappings":"+WAsEM,UAAqBA,QACzBA,EAAOC,UACPA,EAAY,iBAAgBC,OAC5BA,EAAMC,YACNA,EAAWC,iBACXA,EAAmB,UAASC,OAC5BA,EAAMC,cACNA,EAAaC,WACbA,IAEA,MAAMC,EAAcC,EAAAA,OAAeC,EAAKA,UACjCC,EAAQC,GAAaC,EAAQA,SAAC,CAAEC,EAAG,EAAGC,EAAG,IAC1CC,EAAcd,GAAU,CAAEe,SAAUC,EAAcA,eAAEC,WAAY,EAAID,EAAAA,iBACnEE,EAAWC,GAAgBR,EAAQA,UAAC,GAErCS,EAAYb,SAA2B,MACvCc,EAAmBd,EAAAA,SAmBnBe,EAAe,KACnBD,EAAiBE,QAAUC,YAAW,KACpCL,GAAa,EAAM,GAClB,GAAG,EAGFM,EAAgBC,EAAAA,aAvBLC,IACfjB,EAAU,CAAEE,EAAGe,EAAMC,QAASf,EAAGc,EAAME,UACvCV,GAAa,EAAK,IAGC,CAACQ,EAAqBG,KAEjB,UAAtBH,EAAMI,aACNJ,EAAMK,aAAeC,MAAMC,WAC3BP,EAAMK,aAAeC,MAAME,iBAE3BzB,EAAU,CAAEE,EAAGe,EAAMC,QAASf,EAAGc,EAAME,UACvCT,EAAUG,QAAUO,EACpBX,GAAa,GACd,GASsDG,EAAclB,GAoCjEgC,EAAuB,YAAXjC,EAAuBiB,EAAY,CAAEG,QAASd,GAC1D4B,EACJnB,GAAepB,IAAYO,EACzBiC,EAAAA,IAACC,EAAAA,MACC,CAAAC,SAAAF,EAAAA,IAACG,EAAQA,SAAA,CACPL,UAAWA,EACXrC,UAAWA,EACXe,YAAaA,EACb4B,YAAa,CACXzB,UAAsB,YAAXd,EACXY,SAAqB,YAAXZ,GAEZwC,aAAc,CAAE1B,WAAW,EAAMF,UAAU,GAC3CyB,SAAAF,EAAAA,IAAA,MAAA,CACEM,KAAK,UACLC,GAAIvC,EAAYiB,QAChBuB,UAAWC,aAAW,CACpBC,EAAAA,OAAOC,gBACc,YAArB/C,EAAiC8C,SAAOE,mBAAgBC,IAE1DC,MAA4B,YAArBlD,EAAiC,CAAED,oBAAgBkD,EAC1DE,eA5CoB,KAC5BC,aAAajC,EAAiBE,QAAQ,EA4C9BgC,eAAgBjC,EACfkB,SAAA1C,QAIL,KAEN,MAAO,CACLuC,iBACAmB,aAAc,CACZ,mBAAuC,OAAnBnB,EAA0B/B,EAAYiB,aAAU4B,KACjEM,EAAAA,WAAWhC,EAAe,CAC3BiC,QArDW/B,IAEE,YAAfA,EAAMgC,MACS,cAAfhC,EAAMgC,MACS,eAAfhC,EAAMgC,MACS,cAAfhC,EAAMgC,MACS,QAAfhC,EAAMgC,MAENxC,GAAa,EACd,EA6CGyC,UA1CajC,IACE,WAAfA,EAAMgC,OACRhC,EAAMkC,iBACN1C,GAAa,GACd,EAuCG2C,QAtEWnC,IACXA,EAAMK,aAAeC,MAAMC,WAAaP,EAAMK,aAAeC,MAAME,iBACrEf,EAAUG,QAAUI,EAAMoC,OAC1B5C,GAAa,GACd,EAmEG6C,OAhES,KACb7C,GAAa,EAAM,KAmEvB"}

package/amd/useDensity-622a2d34.js

@@ -0,0 +1,2 @@
+define(['exports', 'preact/hooks', './LayerHost-1a734852', 'preact/jsx-runtime', 'preact/compat'], (function(t,e,n,o,r){"use strict";t.useDensity=function(){return e.useContext(n.EnvironmentContext).density}}));
+//# sourceMappingURL=useDensity-622a2d34.js.map

package/amd/useDensity-622a2d34.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDensity-622a2d34.js","sources":["../../src/hooks/UNSAFE_useDensity/useDensity.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\nimport { useContext } from 'preact/hooks';\nimport { EnvironmentContext } from '../../UNSAFE_Environment';\n\nexport function useDensity() {\n  return useContext(EnvironmentContext).density;\n}\n"],"names":["useContext","EnvironmentContext","density"],"mappings":"wJAWE,OAAOA,EAAUA,WAACC,sBAAoBC,OACxC"}

package/amd/useDetectHorizontalOverflow-e729b857.js

@@ -0,0 +1,2 @@
+define(['exports', 'preact/hooks', './useResizeObserver-25032462', './tabBarUtils-ccb7094d'], (function(e,t,r,n){"use strict";const s=(e,t,r)=>{if(null==e)return!0;if(e&&t&&r){const n=[...e,...t];return n.length!==r.length||JSON.stringify(r)!==JSON.stringify(n)}return!1},c=(e,t)=>{if(null==e||null==t)return null;let r=-1;for(let n=0;n<e.length&&e[n]<=t;n++)r=n;return r};e.useDetectHorizontalOverflow=function({rootRef:e,keysArray:i,isTruncationDisabled:u=!0}){const[l,o]=t.useState(),[a,f]=t.useState(),h=t.useRef(new Map),[d,m]=t.useState(),[v,y]=t.useState(0),b=t.useRef(!1),p=t.useRef(!1),R=t.useRef();t.useLayoutEffect((()=>{const t=e?.current?.clientWidth,r=e?.current?.scrollWidth;if(e.current&&i&&i.length>0&&t&&t>0&&(v!==t&&y(t),void 0===d)){if(t>0&&t<r)if(b.current)R.current=R.current?.map((e=>({...e})));else{const r=n.getTabWidths(e.current,h,u,t,b?.current,i);r.every((e=>e.hasReachedLimit))&&(b.current=!0),R.current=r}else m((e=>e));if(!u){const e=new Map(R.current?.map((e=>[e.key,e.maxWidth+"px"])));m(e)}if(t<r){const r=R.current?.map((e=>e.cumulativeWidth)),s=r.length-1;if(r&&t<r[s]){const s=c(r,t-48);if(null!=s){const r=s+1;if(o(i.slice(0,r)),f(i?.slice(r)),r>1&&!p.current&&!u){const r=n.getTabWidths(e.current,h,u,t,b?.current),s=new Map(r.map((e=>[e.key,e.maxWidth+"px"])));p.current=!0,m(s)}}}}}}),[i,e,v,d,u]);const W=t.useCallback((t=>{const r=Math.ceil(t.contentRect.width);Math.abs(v-t.contentRect.width)>1&&(y(t.contentRect.width),void 0===d||b.current||m(void 0),r>=e.current?.scrollWidth&&(o(i),f([])),p.current=!1)}),[v,d,e,i]);return r.useResizeObserver(e,W),s(l,a,i)?{visibleItemKeys:i,overflowItemKeys:a,maxWidths:d}:{visibleItemKeys:l,overflowItemKeys:a,maxWidths:d}}}));
+//# sourceMappingURL=useDetectHorizontalOverflow-e729b857.js.map

package/amd/useDetectHorizontalOverflow-e729b857.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDetectHorizontalOverflow-e729b857.js","sources":["../../src/hooks/PRIVATE_useDetectHorizontalOverflow/useDetectHorizontalOverflow.ts"],"sourcesContent":["import { RefObject } from 'preact';\nimport { useState, useLayoutEffect, useRef, StateUpdater, useCallback } from 'preact/hooks';\nimport { useResizeObserver } from '../../hooks/UNSAFE_useResizeObserver';\nimport { Size } from '../../utils/UNSAFE_size';\nimport { getTabWidths } from '../../utils/PRIVATE_tabBarUtils';\nimport type { TrailingContentInfo } from '../../utils/PRIVATE_tabBarUtils';\n\ntype TabDimensions<K extends string | number> = {\n  key: K;\n  maxWidth: number;\n  nonTextWidth?: number;\n  needsTruncation?: boolean;\n  cumulativeWidth?: number;\n};\n\n//The minimum width of the overflowtabbaritem, it can be rendered with width greater than this based on available width\nconst MORE_ITEM_WIDTH = 48;\n\nexport type useDetectOverflowProps<K extends string | number> = {\n  rootRef: RefObject<HTMLDivElement>;\n  keysArray: (K | undefined)[];\n  isTruncationDisabled?: boolean;\n};\n\n/**\n * Implements overflow detection and calculation\n */\nexport function useDetectHorizontalOverflow<K extends string | number>({\n  rootRef,\n  keysArray,\n  isTruncationDisabled = true\n}: useDetectOverflowProps<K>) {\n  const [visibleItemKeys, setVisibleItemKeys] = useState<(K | undefined)[]>();\n  const [overflowItemKeys, setOverflowingItemKeys] = useState<(K | undefined)[]>();\n  const trailingContentWidths = useRef(new Map<K, TrailingContentInfo>());\n  const [tabMaxWidth, setTabMaxWidth] = useState<Map<K, Size>>();\n  // This state var is to only re-trigger the layout effect. Using it locally will not give the latest updated value hence we use current suffix vars\n  const [tabBarWidth, setTabBarWidth] = useState<number>(0);\n  const isAllItemsTruncatedMax = useRef<boolean>(false);\n  const isAllItemsTruncatedFinal = useRef<boolean>(false);\n  const tabDimensions = useRef<TabDimensions<K>[]>();\n\n  useLayoutEffect(() => {\n    // On initial render, tabBarWidth is 0 until ResizeObserver invokes its callback.\n    // Read the mounted TabBar's width so overflow can be calculated before that callback.\n    // A TabBar that is initially hidden can still measure as 0; ResizeObserver recalculates\n    // overflow when it becomes visible.\n    const tabBarWidthCurrent = rootRef?.current?.clientWidth;\n    const tabBarScrollWidthCurrent = rootRef?.current?.scrollWidth;\n    if (\n      rootRef.current &&\n      keysArray &&\n      keysArray.length > 0 &&\n      tabBarWidthCurrent &&\n      tabBarWidthCurrent > 0\n    ) {\n      //Set tabBarWidth if not the current value\n      if (tabBarWidth !== tabBarWidthCurrent) {\n        setTabBarWidth(tabBarWidthCurrent);\n      }\n\n      if (tabMaxWidth === undefined) {\n        const isOverflow = tabBarWidthCurrent > 0 && tabBarWidthCurrent < tabBarScrollWidthCurrent!;\n\n        //If there is no overflow maxWidth should be its prevState, prevState may also be undefined if truncation is disabled.\n        if (!isOverflow) {\n          setTabMaxWidth((prevState) => {\n            return prevState;\n          });\n        } else {\n          //We need to calculate maxWidth only if truncation threshold limit is not reached\n          if (!isAllItemsTruncatedMax.current) {\n            const tabWidths = getTabWidths(\n              rootRef.current,\n              trailingContentWidths,\n              isTruncationDisabled,\n              tabBarWidthCurrent,\n              isAllItemsTruncatedMax?.current,\n              keysArray as K[]\n            );\n            //If all items have reached max treshold of truncation then we set it to true\n            if (tabWidths.every((item) => item.hasReachedLimit)) {\n              isAllItemsTruncatedMax.current = true;\n            }\n            tabDimensions.current = tabWidths as any;\n          }\n          //If all items have reached max treshold of truncation then we do not have update tabDimensions are maxWidth cannot go lesser than 96px.\n          else {\n            tabDimensions.current = tabDimensions.current?.map((item) => ({\n              ...item\n            }));\n          }\n        }\n\n        //Set calculated maxWidths\n        if (!isTruncationDisabled) {\n          const tabMaxWidthMap = new Map(\n            tabDimensions.current?.map((tab) => [tab.key, (tab.maxWidth + 'px') as Size])\n          );\n          setTabMaxWidth(tabMaxWidthMap);\n        }\n        //Overflow calculation\n        if (tabBarWidthCurrent < tabBarScrollWidthCurrent!) {\n          const arr = tabDimensions.current?.map((item) => item.cumulativeWidth) as number[];\n          const lastIndex = arr.length - 1;\n          //In addition to scrollWidth we check if the cumulative width of last item is greater than rootRef clientwidth\n          if (arr && tabBarWidthCurrent < arr[lastIndex]) {\n            // Reserve space for the More item before finding the last tab that fits.\n            const availableWidth = tabBarWidthCurrent - MORE_ITEM_WIDTH;\n            const closestIndex = searchClosest(arr, availableWidth);\n            if (closestIndex != null) {\n              // `closestIndex` is the last visible item index; `slice` takes an exclusive end index.\n              const visibleItemCount = closestIndex + 1;\n              setVisibleItemKeys(keysArray.slice(0, visibleItemCount));\n              setOverflowingItemKeys(keysArray?.slice(visibleItemCount));\n              //Once OverflowTabBarItem is rendered, i.e overflowItemKeys move into overflow menu then space is available, which can be re-dsitributed to truncated visible items. We also check if these visible items have already gone through this calculation otherwise we skip it to avoid infinite loop.\n              if (\n                visibleItemCount > 1 &&\n                !isAllItemsTruncatedFinal.current &&\n                !isTruncationDisabled\n              ) {\n                const tabWidthsAfterOverflow = getTabWidths(\n                  rootRef.current,\n                  trailingContentWidths,\n                  isTruncationDisabled,\n                  tabBarWidthCurrent,\n                  isAllItemsTruncatedMax?.current\n                );\n                const tabMaxWidthMapAfterOverflow = new Map(\n                  tabWidthsAfterOverflow.map((tab) => [tab.key, (tab.maxWidth + 'px') as Size])\n                );\n                //Flag to indicate that final truncation calculation has occured\n                isAllItemsTruncatedFinal.current = true;\n                setTabMaxWidth(tabMaxWidthMapAfterOverflow);\n              }\n            }\n          }\n        }\n      }\n    }\n  }, [keysArray, rootRef, tabBarWidth, tabMaxWidth, isTruncationDisabled]);\n\n  const updateTabBarWidth = useCallback(\n    (entry: { contentRect: { width: StateUpdater<number> } }) => {\n      const rectWidth = Math.ceil(entry.contentRect.width as number);\n      // Sometimes entry.contentRect.width maybe a decimal value so we need to get absolute value\n      if (Math.abs(tabBarWidth - (entry.contentRect.width as number)) > 1) {\n        setTabBarWidth(entry.contentRect.width);\n        if (tabMaxWidth !== undefined && !isAllItemsTruncatedMax.current) {\n          setTabMaxWidth(undefined);\n        }\n        //Once there is change in the container width and there is no overflow we render all items as visible.\n        if (rectWidth >= rootRef.current?.scrollWidth!) {\n          setVisibleItemKeys(keysArray);\n          setOverflowingItemKeys([]);\n        }\n        isAllItemsTruncatedFinal.current = false;\n      }\n    },\n    [tabBarWidth, tabMaxWidth, rootRef, keysArray]\n  );\n\n  useResizeObserver(rootRef, updateTabBarWidth);\n\n  return shouldRenderAllTabs(visibleItemKeys, overflowItemKeys, keysArray)\n    ? {\n        visibleItemKeys: keysArray,\n        overflowItemKeys,\n        maxWidths: tabMaxWidth\n      }\n    : {\n        visibleItemKeys,\n        overflowItemKeys,\n        maxWidths: tabMaxWidth\n      };\n}\n\n//If the overflow + visible keys or their quantity are not the same as keysArray then we first render all the keys as visible\nconst shouldRenderAllTabs = <K extends string | number>(\n  visibleItemKeys: (K | undefined)[] | undefined,\n  overflowItemKeys: (K | undefined)[] | undefined,\n  keysArray: (K | undefined)[]\n) => {\n  if (visibleItemKeys == null) return true;\n  else if (visibleItemKeys && overflowItemKeys && keysArray) {\n    const combinedArray = [...visibleItemKeys, ...overflowItemKeys];\n    const isNotEqual =\n      combinedArray.length !== keysArray.length ||\n      JSON.stringify(keysArray) !== JSON.stringify(combinedArray);\n    return isNotEqual;\n  } else return false;\n};\n\n// Returns the index of the largest cumulative width that fits the available width.\n// The caller reserves the More-item width before calling this function.\nconst searchClosest = (\n  arr: number[] | undefined,\n  availableWidth: number | undefined | null\n): number | null => {\n  if (arr == null || availableWidth == null) {\n    return null;\n  }\n\n  let closestIndex = -1;\n\n  for (let index = 0; index < arr.length; index++) {\n    if (arr[index] <= availableWidth) {\n      closestIndex = index;\n    } else {\n      break;\n    }\n  }\n\n  return closestIndex;\n};\n"],"names":["shouldRenderAllTabs","visibleItemKeys","overflowItemKeys","keysArray","combinedArray","length","JSON","stringify","searchClosest","arr","availableWidth","closestIndex","index","rootRef","isTruncationDisabled","setVisibleItemKeys","useState","setOverflowingItemKeys","trailingContentWidths","useRef","Map","tabMaxWidth","setTabMaxWidth","tabBarWidth","setTabBarWidth","isAllItemsTruncatedMax","isAllItemsTruncatedFinal","tabDimensions","useLayoutEffect","tabBarWidthCurrent","current","clientWidth","tabBarScrollWidthCurrent","scrollWidth","undefined","map","item","tabWidths","getTabWidths","every","hasReachedLimit","prevState","tabMaxWidthMap","tab","key","maxWidth","cumulativeWidth","lastIndex","visibleItemCount","slice","tabWidthsAfterOverflow","tabMaxWidthMapAfterOverflow","updateTabBarWidth","useCallback","entry","rectWidth","Math","ceil","contentRect","width","abs","useResizeObserver","maxWidths"],"mappings":"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"}

package/amd/useDisplayValue-6ad8d409.js

@@ -1,2 +1,2 @@
-define(['exports', 'preact/jsx-runtime', './IconButton-be3bd92a', './NavLeft-12e00b81', 'preact/hooks', './keyboardUtils-fb6219eb', 'preact/compat', './TextFieldInput-b220bd88', 'css!./ObfuscatedTextFieldInputStyles.styles.css', './useAccessibleContext-23e8a333', './logger-00b673c5', './FormContext-6b0879a0', './FormFieldContext-a024b891', './useFormFieldContext-9260f081', './TabbableModeContext-a9c97640', './useTranslationBundle-e4dd341e', './textAlign-ef924afd', 'css!./FormControlUtilsStyles.styles.css', 'css!./ReadonlyTextFieldInputStyles.styles.css', './UNSAFE_TextField/themes/redwood/ReadonlyTextFieldInputVariants.css', './StyledTextField-2b9c440e', './TextField-9e466a1b', 'css!./LiveRegionStyles.styles.css', './LayerHost-0b288129', './UNSAFE_TextField/themes/TextFieldStyles.css', 'css!./SkeletonStyles.styles.css', 'css!./TextFieldLoadingStyles.styles.css', 'css!./TextFieldStyles.styles.css', 'module', './UNSAFE_TextField/themes/redwood/TextFieldVariants.css', './useSelectCommon-0abad82b', './LiveRegion-dbefb95b', 'css!./LabelValueLayoutStyles.styles.css', 'css!./LabelStyles.styles.css', 'module', './UNSAFE_Label/themes/redwood/LabelVariants.css', './UNSAFE_TextField/themes/FormLayoutStyles.css', 'module', './Flex-4b81b412', 'css!./LayoutStyles.styles.css', './InputGroupContext-372087af', 'css!./TooltipContentStyles.styles.css', 'module', './hooks/UNSAFE_useTooltip/themes/redwood/TooltipContentVariants.css', './tooltipUtils-d855e8f2'], (function(e,t,s,o,l,n,a,i,d,r,c,u,F,x,b,S,y,h,m,T,p,C,w,A,L,g,f,v,B,I,_,U,j,k,N,E,V,D,R,$,M,z,O,G,H){"use strict";e.SelectSingleField=function({children:e,hasInsideLabel:l,isBackButtonShown:n,isClearButtonShown:a,isDropdownArrowShown:i,onBackButtonClick:d,onClearButtonClick:r,onDropdownArrowClick:c,...u}){const F=S.useTranslationBundle("@oracle/oraclejet-preact"),{isDisabled:b,isLoading:y}=x.useFormFieldContext(),h=n?t.jsx(s.IconButton,{"aria-label":F.selectMultiple_back(),size:"xs",variant:"ghost",onAction:d,children:t.jsx(o.SvgNavLeft,{})}):null,m=y?void 0:t.jsxs(t.Fragment,{children:[a&&t.jsx(s.IconButton,{"aria-label":F.formControl_clear(),size:"sm",variant:"ghost",onAction:r,children:t.jsx(o.SvgCancelS,{})}),i&&t.jsx(_.DropdownArrow,{isDisabled:b,onClick:c,testId:`${u.testId}_dropdownarrow`})]});return t.jsx(C.TextField,{startContent:h,mainContent:e,endContent:m,...u})},e.SelectSingleFieldInput=function({displayValue:e,isAddToListShown:s,isAdvancedSearchShown:o,isUserFiltering:l,liveRegionText:n,userInput:a,virtualKeyboard:d,...r}){const c=S.useTranslationBundle("@oracle/oraclejet-preact"),u=c.select_addToListAvailable(),F=c.select_moreSearchOptionsAvailable(),x=`${n} ${s?u:""} ${o?F:""}`;return t.jsxs(t.Fragment,{children:[t.jsx(i.TextFieldInput,{...r,hasEndContent:!0,"aria-autocomplete":"list",autoComplete:"off",role:"combobox",spellcheck:!1,type:"auto"===d?"search":d,value:l?a:e}),t.jsx(U.LiveRegion,{children:x})]})},e.useDisplayValue=function(e,t,s="SelectSingle"){return l.useMemo((()=>void 0===t?"":_.renderItemText(t,e,s)??""),[t,e,s])}}));
+define(['exports', 'preact/jsx-runtime', './IconButton-be3bd92a', './NavLeft-12e00b81', 'preact/hooks', './keyboardUtils-fb6219eb', 'preact/compat', './TextFieldInput-b220bd88', 'css!./ObfuscatedTextFieldInputStyles.styles.css', './useAccessibleContext-23e8a333', './logger-00b673c5', './FormContext-6b0879a0', './FormFieldContext-a024b891', './useFormFieldContext-9260f081', './TabbableModeContext-a9c97640', './useTranslationBundle-db326955', './textAlign-ef924afd', 'css!./FormControlUtilsStyles.styles.css', 'css!./ReadonlyTextFieldInputStyles.styles.css', './UNSAFE_TextField/themes/redwood/ReadonlyTextFieldInputVariants.css', './StyledTextField-2b9c440e', './TextField-9e466a1b', 'css!./LiveRegionStyles.styles.css', './LayerHost-1a734852', './UNSAFE_TextField/themes/TextFieldStyles.css', 'css!./SkeletonStyles.styles.css', 'css!./TextFieldLoadingStyles.styles.css', 'css!./TextFieldStyles.styles.css', 'module', './UNSAFE_TextField/themes/redwood/TextFieldVariants.css', './useSelectCommon-0abad82b', './LiveRegion-1553833d', 'css!./LabelValueLayoutStyles.styles.css', 'css!./LabelStyles.styles.css', 'module', './UNSAFE_Label/themes/redwood/LabelVariants.css', './UNSAFE_TextField/themes/FormLayoutStyles.css', 'module', './Flex-71f83c12', 'css!./LayoutStyles.styles.css', './InputGroupContext-372087af', 'css!./TooltipContentStyles.styles.css', 'module', './hooks/UNSAFE_useTooltip/themes/redwood/TooltipContentVariants.css', './tooltipUtils-2f3b01e4'], (function(e,t,s,o,l,n,a,i,r,d,c,u,F,x,S,y,b,h,m,T,p,C,w,A,L,g,f,v,B,I,_,U,j,k,N,E,V,D,R,$,M,z,O,G,H){"use strict";e.SelectSingleField=function({children:e,hasInsideLabel:l,isBackButtonShown:n,isClearButtonShown:a,isDropdownArrowShown:i,onBackButtonClick:r,onClearButtonClick:d,onDropdownArrowClick:c,...u}){const F=y.useTranslationBundle("@oracle/oraclejet-preact"),{isDisabled:S,isLoading:b}=x.useFormFieldContext(),h=n?t.jsx(s.IconButton,{"aria-label":F.selectMultiple_back(),size:"xs",variant:"ghost",onAction:r,children:t.jsx(o.SvgNavLeft,{})}):null,m=b?void 0:t.jsxs(t.Fragment,{children:[a&&t.jsx(s.IconButton,{"aria-label":F.formControl_clear(),size:"sm",variant:"ghost",onAction:d,children:t.jsx(o.SvgCancelS,{})}),i&&t.jsx(_.DropdownArrow,{isDisabled:S,onClick:c,testId:`${u.testId}_dropdownarrow`})]});return t.jsx(C.TextField,{startContent:h,mainContent:e,endContent:m,...u})},e.SelectSingleFieldInput=function({displayValue:e,isAddToListShown:s,isAdvancedSearchShown:o,isUserFiltering:l,liveRegionText:n,userInput:a,virtualKeyboard:r,...d}){const c=y.useTranslationBundle("@oracle/oraclejet-preact"),u=c.select_addToListAvailable(),F=c.select_moreSearchOptionsAvailable(),x=`${n} ${s?u:""} ${o?F:""}`;return t.jsxs(t.Fragment,{children:[t.jsx(i.TextFieldInput,{...d,hasEndContent:!0,"aria-autocomplete":"list",autoComplete:"off",role:"combobox",spellcheck:!1,type:"auto"===r?"search":r,value:l?a:e}),t.jsx(U.LiveRegion,{children:x})]})},e.useDisplayValue=function(e,t,s="SelectSingle"){return l.useMemo((()=>void 0===t?"":_.renderItemText(t,e,s)??""),[t,e,s])}}));
 //# sourceMappingURL=useDisplayValue-6ad8d409.js.map

package/amd/useExpandCollapse-d8799966.js

@@ -0,0 +1,2 @@
+define(['exports', 'preact/hooks', './useUser-e0677e8d'], (function(e,t,o){"use strict";const r=(e,t,o,r,n)=>{const s=r(t);if(n&&s){const t=o(s);(e&&t||!e&&!t)&&n({value:s})}},n=(e,t,o)=>{const r=t(e.target);o&&r&&(o({value:r}),"click"===e.type&&e.stopPropagation())};e.useExpandCollapse=function(e,s,a,c){const{direction:l}=o.useUser(),i=t.useCallback((t=>{!0!==c&&a&&n(t,e,a)}),[e,a,c]),k=t.useCallback((t=>{if(!0===c||"Enter"!==t.key&&" "!==t.key){if("ArrowLeft"===t.key||"ArrowRight"===t.key){const o="rtl"===l,n="ArrowLeft"===t.key&&!o;r(n,t.target,s,e,a),t.preventDefault(),t.stopPropagation()}}else n(t,e,a)}),[e,a,s,l,c]),u=t.useCallback((e=>{(!0===c||"Enter"!==e.key&&" "!==e.key)&&"ArrowLeft"!==e.key&&"ArrowRight"!==e.key||e.preventDefault()}),[c]);return a?{onClick:i,onKeyDown:u,onKeyUp:k}:{}}}));
+//# sourceMappingURL=useExpandCollapse-d8799966.js.map

package/amd/useExpandCollapse-d8799966.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExpandCollapse-d8799966.js","sources":["../../src/hooks/PRIVATE_useListCommon/useExpandCollapse.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\nimport { useCallback } from 'preact/hooks';\nimport { ToggleDetail } from '#UNSAFE_Collection';\nimport { useUser } from '#hooks/UNSAFE_useUser';\n\n/**\n * A hook that handles mouse and keyboard gesture that toggles the expanded state.\n * @param keyExtractor\n * @param expanded\n * @param onToggle\n * @returns\n */\nexport function useExpandCollapse<K>(\n  keyExtractor: (element: HTMLElement) => K | null,\n  isExpanded: (key: K) => boolean,\n  onToggle?: (detail: ToggleDetail<K>) => void,\n  allowArrowKeysOnly?: boolean\n) {\n  const { direction } = useUser();\n\n  const onClick = useCallback(\n    (event: MouseEvent) => {\n      if (allowArrowKeysOnly !== true && onToggle) {\n        handleToggle(event, keyExtractor, onToggle);\n      }\n    },\n    [keyExtractor, onToggle, allowArrowKeysOnly]\n  );\n\n  const onKeyUp = useCallback(\n    (event: KeyboardEvent) => {\n      if (allowArrowKeysOnly !== true && (event.key === 'Enter' || event.key === ' ')) {\n        handleToggle(event, keyExtractor, onToggle);\n      } else if (event.key === 'ArrowLeft' || event.key === 'ArrowRight') {\n        const isRtl = direction === 'rtl';\n        const isLeftArrow = event.key === 'ArrowLeft' && !isRtl;\n        handleArrowKey(\n          isLeftArrow,\n          event.target as HTMLElement,\n          isExpanded,\n          keyExtractor,\n          onToggle\n        );\n        // arrow key might cause it to scroll horizontally\n        event.preventDefault();\n        event.stopPropagation();\n      }\n    },\n    [keyExtractor, onToggle, isExpanded, direction, allowArrowKeysOnly]\n  );\n\n  // prevent default (propagation) for keyDown to prevent scrolling the container\n  const onKeyDown = useCallback(\n    (event: KeyboardEvent) => {\n      if (allowArrowKeysOnly !== true && (event.key === 'Enter' || event.key === ' ')) {\n        event.preventDefault();\n      } else if (event.key === 'ArrowLeft' || event.key === 'ArrowRight') {\n        event.preventDefault();\n      }\n    },\n    [allowArrowKeysOnly]\n  );\n\n  return onToggle ? { onClick, onKeyDown, onKeyUp } : {};\n}\n\nconst handleArrowKey = <K>(\n  isLeftArrow: boolean,\n  target: HTMLElement,\n  isExpanded: (key: K) => boolean,\n  keyExtractor: (element: HTMLElement) => K | null,\n  onToggle?: (detail: ToggleDetail<K>) => void\n) => {\n  const itemKey = keyExtractor(target);\n  if (onToggle && itemKey) {\n    const contains = isExpanded(itemKey);\n    if ((isLeftArrow && contains) || (!isLeftArrow && !contains)) {\n      onToggle({ value: itemKey });\n    }\n  }\n};\n\nconst handleToggle = <K>(\n  event: Event,\n  keyExtractor: (element: HTMLElement) => K | null,\n  onToggle?: (detail: ToggleDetail<K>) => void\n) => {\n  const itemKey = keyExtractor(event.target as HTMLElement);\n  if (onToggle && itemKey) {\n    onToggle({ value: itemKey });\n    if (event.type === 'click') {\n      event.stopPropagation();\n    }\n  }\n};\n"],"names":["handleArrowKey","isLeftArrow","target","isExpanded","keyExtractor","onToggle","itemKey","contains","value","handleToggle","event","type","stopPropagation","allowArrowKeysOnly","direction","useUser","onClick","useCallback","onKeyUp","key","isRtl","preventDefault","onKeyDown"],"mappings":"qFAwEA,MAAMA,EAAiB,CACrBC,EACAC,EACAC,EACAC,EACAC,KAEA,MAAMC,EAAUF,EAAaF,GAC7B,GAAIG,GAAYC,EAAS,CACvB,MAAMC,EAAWJ,EAAWG,IACvBL,GAAeM,IAAeN,IAAgBM,IACjDF,EAAS,CAAEG,MAAOF,GAErB,GAGGG,EAAe,CACnBC,EACAN,EACAC,KAEA,MAAMC,EAAUF,EAAaM,EAAMR,QAC/BG,GAAYC,IACdD,EAAS,CAAEG,MAAOF,IACC,UAAfI,EAAMC,MACRD,EAAME,kBAET,sBAjFG,SACJR,EACAD,EACAE,EACAQ,GAEA,MAAMC,UAAEA,GAAcC,EAAAA,UAEhBC,EAAUC,eACbP,KAC4B,IAAvBG,GAA+BR,GACjCI,EAAaC,EAAON,EAAcC,EACnC,GAEH,CAACD,EAAcC,EAAUQ,IAGrBK,EAAUD,eACbP,IACC,IAA2B,IAAvBG,GAA8C,UAAdH,EAAMS,KAAiC,MAAdT,EAAMS,KAE5D,GAAkB,cAAdT,EAAMS,KAAqC,eAAdT,EAAMS,IAAsB,CAClE,MAAMC,EAAsB,QAAdN,EACRb,EAA4B,cAAdS,EAAMS,MAAwBC,EAClDpB,EACEC,EACAS,EAAMR,OACNC,EACAC,EACAC,GAGFK,EAAMW,iBACNX,EAAME,iBACP,OAdCH,EAAaC,EAAON,EAAcC,EAcnC,GAEH,CAACD,EAAcC,EAAUF,EAAYW,EAAWD,IAI5CS,EAAYL,eACfP,MAC4B,IAAvBG,GAA8C,UAAdH,EAAMS,KAAiC,MAAdT,EAAMS,MAE1C,cAAdT,EAAMS,KAAqC,eAAdT,EAAMS,KAD5CT,EAAMW,gBAGP,GAEH,CAACR,IAGH,OAAOR,EAAW,CAAEW,UAASM,YAAWJ,WAAY,CAAA,CACtD"}

package/amd/useFloating-0bdf9133.js

@@ -0,0 +1,2 @@
+define(['exports', 'preact/hooks', './useUser-e0677e8d', './positionUtils-6e4daa31'], (function(t,e,n,o){"use strict";const r=Math.min,i=Math.max,s=Math.round,l=Math.floor,c=t=>({x:t,y:t}),a={left:"right",right:"left",bottom:"top",top:"bottom"},f={start:"end",end:"start"};function u(t,e,n){return i(t,r(e,n))}function d(t,e){return"function"==typeof t?t(e):t}function m(t){return t.split("-")[0]}function p(t){return t.split("-")[1]}function h(t){return"x"===t?"y":"x"}function g(t){return"y"===t?"height":"width"}function y(t){return["top","bottom"].includes(m(t))?"y":"x"}function x(t){return h(y(t))}function w(t){return t.replace(/start|end/g,(t=>f[t]))}function b(t){return t.replace(/left|right|bottom|top/g,(t=>a[t]))}function v(t){return"number"!=typeof t?function(t){return{top:0,right:0,bottom:0,left:0,...t}}(t):{top:t,right:t,bottom:t,left:t}}function A(t){return{...t,top:t.y,left:t.x,right:t.x+t.width,bottom:t.y+t.height}}function R(t,e,n){let{reference:o,floating:r}=t;const i=y(e),s=x(e),l=g(s),c=m(e),a="y"===i,f=o.x+o.width/2-r.width/2,u=o.y+o.height/2-r.height/2,d=o[l]/2-r[l]/2;let h;switch(c){case"top":h={x:f,y:o.y-r.height};break;case"bottom":h={x:f,y:o.y+o.height};break;case"right":h={x:o.x+o.width,y:u};break;case"left":h={x:o.x-r.width,y:u};break;default:h={x:o.x,y:o.y}}switch(p(e)){case"start":h[s]-=d*(n&&a?-1:1);break;case"end":h[s]+=d*(n&&a?-1:1)}return h}async function L(t,e){var n;void 0===e&&(e={});const{x:o,y:r,platform:i,rects:s,elements:l,strategy:c}=t,{boundary:a="clippingAncestors",rootBoundary:f="viewport",elementContext:u="floating",altBoundary:m=!1,padding:p=0}=d(e,t),h=v(p),g=l[m?"floating"===u?"reference":"floating":u],y=A(await i.getClippingRect({element:null==(n=await(null==i.isElement?void 0:i.isElement(g)))||n?g:g.contextElement||await(null==i.getDocumentElement?void 0:i.getDocumentElement(l.floating)),boundary:a,rootBoundary:f,strategy:c})),x="floating"===u?{...s.floating,x:o,y:r}:s.reference,w=await(null==i.getOffsetParent?void 0:i.getOffsetParent(l.floating)),b=await(null==i.isElement?void 0:i.isElement(w))&&await(null==i.getScale?void 0:i.getScale(w))||{x:1,y:1},R=A(i.convertOffsetParentRelativeRectToViewportRelativeRect?await i.convertOffsetParentRelativeRectToViewportRelativeRect({rect:x,offsetParent:w,strategy:c}):x);return{top:(y.top-R.top+h.top)/b.y,bottom:(R.bottom-y.bottom+h.bottom)/b.y,left:(y.left-R.left+h.left)/b.x,right:(R.right-y.right+h.right)/b.x}}const T=function(t){return void 0===t&&(t=0),{name:"offset",options:t,async fn(e){const{x:n,y:o}=e,r=await async function(t,e){const{placement:n,platform:o,elements:r}=t,i=await(null==o.isRTL?void 0:o.isRTL(r.floating)),s=m(n),l=p(n),c="y"===y(n),a=["left","top"].includes(s)?-1:1,f=i&&c?-1:1,u=d(e,t);let{mainAxis:h,crossAxis:g,alignmentAxis:x}="number"==typeof u?{mainAxis:u,crossAxis:0,alignmentAxis:null}:{mainAxis:0,crossAxis:0,alignmentAxis:null,...u};return l&&"number"==typeof x&&(g="end"===l?-1*x:x),c?{x:g*f,y:h*a}:{x:h*a,y:g*f}}(e,t);return{x:n+r.x,y:o+r.y,data:r}}}};function E(t){return O(t)?(t.nodeName||"").toLowerCase():"#document"}function D(t){var e;return(null==t||null==(e=t.ownerDocument)?void 0:e.defaultView)||window}function S(t){var e;return null==(e=(O(t)?t.ownerDocument:t.document)||window.document)?void 0:e.documentElement}function O(t){return t instanceof Node||t instanceof D(t).Node}function P(t){return t instanceof Element||t instanceof D(t).Element}function k(t){return t instanceof HTMLElement||t instanceof D(t).HTMLElement}function C(t){return"undefined"!=typeof ShadowRoot&&(t instanceof ShadowRoot||t instanceof D(t).ShadowRoot)}function F(t){const{overflow:e,overflowX:n,overflowY:o,display:r}=z(t);return/auto|scroll|overlay|hidden|clip/.test(e+o+n)&&!["inline","contents"].includes(r)}function H(t){return["table","td","th"].includes(E(t))}function W(t){const e=$(),n=z(t);return"none"!==n.transform||"none"!==n.perspective||!!n.containerType&&"normal"!==n.containerType||!e&&!!n.backdropFilter&&"none"!==n.backdropFilter||!e&&!!n.filter&&"none"!==n.filter||["transform","perspective","filter"].some((t=>(n.willChange||"").includes(t)))||["paint","layout","strict","content"].some((t=>(n.contain||"").includes(t)))}function $(){return!("undefined"==typeof CSS||!CSS.supports)&&CSS.supports("-webkit-backdrop-filter","none")}function M(t){return["html","body","#document"].includes(E(t))}function z(t){return D(t).getComputedStyle(t)}function B(t){return P(t)?{scrollLeft:t.scrollLeft,scrollTop:t.scrollTop}:{scrollLeft:t.pageXOffset,scrollTop:t.pageYOffset}}function V(t){if("html"===E(t))return t;const e=t.assignedSlot||t.parentNode||C(t)&&t.host||S(t);return C(e)?e.host:e}function j(t){const e=V(t);return M(e)?t.ownerDocument?t.ownerDocument.body:t.body:k(e)&&F(e)?e:j(e)}function N(t,e){var n;void 0===e&&(e=[]);const o=j(t),r=o===(null==(n=t.ownerDocument)?void 0:n.body),i=D(o);return r?e.concat(i,i.visualViewport||[],F(o)?o:[]):e.concat(o,N(o))}function U(t){const e=z(t);let n=parseFloat(e.width)||0,o=parseFloat(e.height)||0;const r=k(t),i=r?t.offsetWidth:n,l=r?t.offsetHeight:o,c=s(n)!==i||s(o)!==l;return c&&(n=i,o=l),{width:n,height:o,$:c}}function I(t){return P(t)?t:t.contextElement}function _(t){const e=I(t);if(!k(e))return c(1);const n=e.getBoundingClientRect(),{width:o,height:r,$:i}=U(e);let l=(i?s(n.width):n.width)/o,a=(i?s(n.height):n.height)/r;return l&&Number.isFinite(l)||(l=1),a&&Number.isFinite(a)||(a=1),{x:l,y:a}}const q=c(0);function X(t){const e=D(t);return $()&&e.visualViewport?{x:e.visualViewport.offsetLeft,y:e.visualViewport.offsetTop}:q}function Y(t,e,n,o){void 0===e&&(e=!1),void 0===n&&(n=!1);const r=t.getBoundingClientRect(),i=I(t);let s=c(1);e&&(o?P(o)&&(s=_(o)):s=_(t));const l=function(t,e,n){return void 0===e&&(e=!1),!(!n||e&&n!==D(t))&&e}(i,n,o)?X(i):c(0);let a=(r.left+l.x)/s.x,f=(r.top+l.y)/s.y,u=r.width/s.x,d=r.height/s.y;if(i){const t=D(i),e=o&&P(o)?D(o):o;let n=t.frameElement;for(;n&&o&&e!==t;){const t=_(n),e=n.getBoundingClientRect(),o=z(n),r=e.left+(n.clientLeft+parseFloat(o.paddingLeft))*t.x,i=e.top+(n.clientTop+parseFloat(o.paddingTop))*t.y;a*=t.x,f*=t.y,u*=t.x,d*=t.y,a+=r,f+=i,n=D(n).frameElement}}return A({width:u,height:d,x:a,y:f})}function G(t){return Y(S(t)).left+B(t).scrollLeft}function J(t,e,n){let o;if("viewport"===e)o=function(t,e){const n=D(t),o=S(t),r=n.visualViewport;let i=o.clientWidth,s=o.clientHeight,l=0,c=0;if(r){i=r.width,s=r.height;const t=$();(!t||t&&"fixed"===e)&&(l=r.offsetLeft,c=r.offsetTop)}return{width:i,height:s,x:l,y:c}}(t,n);else if("document"===e)o=function(t){const e=S(t),n=B(t),o=t.ownerDocument.body,r=i(e.scrollWidth,e.clientWidth,o.scrollWidth,o.clientWidth),s=i(e.scrollHeight,e.clientHeight,o.scrollHeight,o.clientHeight);let l=-n.scrollLeft+G(t);const c=-n.scrollTop;return"rtl"===z(o).direction&&(l+=i(e.clientWidth,o.clientWidth)-r),{width:r,height:s,x:l,y:c}}(S(t));else if(P(e))o=function(t,e){const n=Y(t,!0,"fixed"===e),o=n.top+t.clientTop,r=n.left+t.clientLeft,i=k(t)?_(t):c(1);return{width:t.clientWidth*i.x,height:t.clientHeight*i.y,x:r*i.x,y:o*i.y}}(e,n);else{const n=X(t);o={...e,x:e.x-n.x,y:e.y-n.y}}return A(o)}function K(t,e){const n=V(t);return!(n===e||!P(n)||M(n))&&("fixed"===z(n).position||K(n,e))}function Q(t,e,n){const o=k(e),r=S(e),i="fixed"===n,s=Y(t,!0,i,e);let l={scrollLeft:0,scrollTop:0};const a=c(0);if(o||!o&&!i)if(("body"!==E(e)||F(r))&&(l=B(e)),o){const t=Y(e,!0,i,e);a.x=t.x+e.clientLeft,a.y=t.y+e.clientTop}else r&&(a.x=G(r));return{x:s.left+l.scrollLeft-a.x,y:s.top+l.scrollTop-a.y,width:s.width,height:s.height}}function Z(t,e){return k(t)&&"fixed"!==z(t).position?e?e(t):t.offsetParent:null}function tt(t,e){const n=D(t);if(!k(t))return n;let o=Z(t,e);for(;o&&H(o)&&"static"===z(o).position;)o=Z(o,e);return o&&("html"===E(o)||"body"===E(o)&&"static"===z(o).position&&!W(o))?n:o||function(t){let e=V(t);for(;k(e)&&!M(e);){if(W(e))return e;e=V(e)}return null}(t)||n}const et={convertOffsetParentRelativeRectToViewportRelativeRect:function(t){let{rect:e,offsetParent:n,strategy:o}=t;const r=k(n),i=S(n);if(n===i)return e;let s={scrollLeft:0,scrollTop:0},l=c(1);const a=c(0);if((r||!r&&"fixed"!==o)&&(("body"!==E(n)||F(i))&&(s=B(n)),k(n))){const t=Y(n);l=_(n),a.x=t.x+n.clientLeft,a.y=t.y+n.clientTop}return{width:e.width*l.x,height:e.height*l.y,x:e.x*l.x-s.scrollLeft*l.x+a.x,y:e.y*l.y-s.scrollTop*l.y+a.y}},getDocumentElement:S,getClippingRect:function(t){let{element:e,boundary:n,rootBoundary:o,strategy:s}=t;const l=[..."clippingAncestors"===n?function(t,e){const n=e.get(t);if(n)return n;let o=N(t).filter((t=>P(t)&&"body"!==E(t))),r=null;const i="fixed"===z(t).position;let s=i?V(t):t;for(;P(s)&&!M(s);){const e=z(s),n=W(s);n||"fixed"!==e.position||(r=null),(i?!n&&!r:!n&&"static"===e.position&&r&&["absolute","fixed"].includes(r.position)||F(s)&&!n&&K(t,s))?o=o.filter((t=>t!==s)):r=e,s=V(s)}return e.set(t,o),o}(e,this._c):[].concat(n),o],c=l[0],a=l.reduce(((t,n)=>{const o=J(e,n,s);return t.top=i(o.top,t.top),t.right=r(o.right,t.right),t.bottom=r(o.bottom,t.bottom),t.left=i(o.left,t.left),t}),J(e,c,s));return{width:a.right-a.left,height:a.bottom-a.top,x:a.left,y:a.top}},getOffsetParent:tt,getElementRects:async function(t){let{reference:e,floating:n,strategy:o}=t;const r=this.getOffsetParent||tt,i=this.getDimensions;return{reference:Q(e,await r(n),o),floating:{x:0,y:0,...await i(n)}}},getClientRects:function(t){return Array.from(t.getClientRects())},getDimensions:function(t){return U(t)},getScale:_,isElement:P,isRTL:function(t){return"rtl"===z(t).direction}};const nt=(t,e,n)=>{const o=new Map,r={platform:et,...n},i={...r.platform,_c:o};return(async(t,e,n)=>{const{placement:o="bottom",strategy:r="absolute",middleware:i=[],platform:s}=n,l=i.filter(Boolean),c=await(null==s.isRTL?void 0:s.isRTL(e));let a=await s.getElementRects({reference:t,floating:e,strategy:r}),{x:f,y:u}=R(a,o,c),d=o,m={},p=0;for(let n=0;n<l.length;n++){const{name:i,fn:h}=l[n],{x:g,y:y,data:x,reset:w}=await h({x:f,y:u,initialPlacement:o,placement:d,strategy:r,middlewareData:m,rects:a,platform:s,elements:{reference:t,floating:e}});f=null!=g?g:f,u=null!=y?y:u,m={...m,[i]:{...m[i],...x}},w&&p<=50&&(p++,"object"==typeof w&&(w.placement&&(d=w.placement),w.rects&&(a=!0===w.rects?await s.getElementRects({reference:t,floating:e,strategy:r}):w.rects),({x:f,y:u}=R(a,d,c))),n=-1)}return{x:f,y:u,placement:d,strategy:r,middlewareData:m}})(t,e,{...r,platform:i})},ot=t=>({name:"offset",options:t,fn:async e=>T((e=>{let n;if(null!=(null!=e.middlewareData.flip?.overflows?e.middlewareData.flip?.overflows[0]:null)&&null!=t&&"object"==typeof t&&(n=rt(e.placement,e.initialPlacement,t)),!t)return 0;return n??t})).fn(e)}),rt=(t,e,n)=>{const o=e.split("-")[0],r=t.split("-")[0],i=e.split("-")[1],s=t.split("-")[1];return("right"===o||"left"===o)&&o===r&&i!==s||("top"===o||"bottom"===o)&&o===r&&i!==s?{mainAxis:n&&"object"==typeof n&&n.mainAxis?n.mainAxis:0,crossAxis:n&&"object"==typeof n&&n.crossAxis?-n.crossAxis:0}:n};function it(t,e){if(t===e)return!0;if(typeof t!=typeof e)return!1;if("function"==typeof t&&t.toString()===e.toString())return!0;let n,o,r;if(t&&e&&"object"==typeof t){if(Array.isArray(t)){if(n=t.length,n!=e.length)return!1;for(o=n;0!=o--;)if(!it(t[o],e[o]))return!1;return!0}if(r=Object.keys(t),n=r.length,n!==Object.keys(e).length)return!1;for(o=n;0!=o--;)if(!Object.prototype.hasOwnProperty.call(e,r[o]))return!1;for(o=n;0!=o--;){const n=r[o];if(("_owner"!==n||!t.$$typeof)&&!it(t[n],e[n]))return!1}return!0}return t!=t&&e!=e}const st=(t,e)=>{const n=t.split("-")[0],r=t.split("-")[1],i=o.normalizePosition(n,e);let s,l;r&&(s={top:"start",bottom:"end"},l=r.replace(/top|bottom/g,(t=>s[t])));const c=["top","right","bottom","left","top-start","right-start","bottom-start","left-start","top-end","right-end","bottom-end","left-end"].filter((t=>l&&t===`${i}-${l}`||!l&&t===`${i}`))[0];return c||"bottom"};t.arrow=t=>({name:"arrow",options:t,async fn(e){const{x:n,y:o,placement:i,rects:s,platform:l,elements:c}=e,{element:a,padding:f=0}=d(t,e)||{};if(null==a)return{};const m=v(f),h={x:n,y:o},y=x(i),w=g(y),b=await l.getDimensions(a),A="y"===y,R=A?"top":"left",L=A?"bottom":"right",T=A?"clientHeight":"clientWidth",E=s.reference[w]+s.reference[y]-h[y]-s.floating[w],D=h[y]-s.reference[y],S=await(null==l.getOffsetParent?void 0:l.getOffsetParent(a));let O=S?S[T]:0;O&&await(null==l.isElement?void 0:l.isElement(S))||(O=c.floating[T]||s.floating[w]);const P=E/2-D/2,k=O/2-b[w]/2-1,C=r(m[R],k),F=r(m[L],k),H=C,W=O-b[w]-F,$=O/2-b[w]/2+P,M=u(H,$,W),z=null!=p(i)&&$!=M&&s.reference[w]/2-($<H?C:F)-b[w]/2<0?$<H?H-$:W-$:0;return{[y]:h[y]-z,data:{[y]:M,centerOffset:$-M+z}}}}),t.autoUpdate=function(t,e,n,o){void 0===o&&(o={});const{ancestorScroll:s=!0,ancestorResize:c=!0,elementResize:a="function"==typeof ResizeObserver,layoutShift:f="function"==typeof IntersectionObserver,animationFrame:u=!1}=o,d=I(t),m=s||c?[...d?N(d):[],...N(e)]:[];m.forEach((t=>{s&&t.addEventListener("scroll",n,{passive:!0}),c&&t.addEventListener("resize",n)}));const p=d&&f?function(t,e){let n,o=null;const s=S(t);function c(){clearTimeout(n),o&&o.disconnect(),o=null}return function a(f,u){void 0===f&&(f=!1),void 0===u&&(u=1),c();const{left:d,top:m,width:p,height:h}=t.getBoundingClientRect();if(f||e(),!p||!h)return;const g={rootMargin:-l(m)+"px "+-l(s.clientWidth-(d+p))+"px "+-l(s.clientHeight-(m+h))+"px "+-l(d)+"px",threshold:i(0,r(1,u))||1};let y=!0;function x(t){const e=t[0].intersectionRatio;if(e!==u){if(!y)return a();e?a(!1,e):n=setTimeout((()=>{a(!1,1e-7)}),100)}y=!1}try{o=new IntersectionObserver(x,{...g,root:s.ownerDocument})}catch(t){o=new IntersectionObserver(x,g)}o.observe(t)}(!0),c}(d,n):null;let h,g=-1,y=null;a&&(y=new ResizeObserver((t=>{let[o]=t;o&&o.target===d&&y&&(y.unobserve(e),cancelAnimationFrame(g),g=requestAnimationFrame((()=>{y&&y.observe(e)}))),n()})),d&&!u&&y.observe(d),y.observe(e));let x=u?Y(t):null;return u&&function e(){const o=Y(t);!x||o.x===x.x&&o.y===x.y&&o.width===x.width&&o.height===x.height||n();x=o,h=requestAnimationFrame(e)}(),n(),()=>{m.forEach((t=>{s&&t.removeEventListener("scroll",n),c&&t.removeEventListener("resize",n)})),p&&p(),y&&y.disconnect(),y=null,u&&cancelAnimationFrame(h)}},t.flip=function(t){return void 0===t&&(t={}),{name:"flip",options:t,async fn(e){var n;const{placement:o,middlewareData:r,rects:i,initialPlacement:s,platform:l,elements:c}=e,{mainAxis:a=!0,crossAxis:f=!0,fallbackPlacements:u,fallbackStrategy:h="bestFit",fallbackAxisSideDirection:y="none",flipAlignment:v=!0,...A}=d(t,e),R=m(o),T=m(s)===s,E=await(null==l.isRTL?void 0:l.isRTL(c.floating)),D=u||(T||!v?[b(s)]:function(t){const e=b(t);return[w(t),e,w(e)]}(s));u||"none"===y||D.push(...function(t,e,n,o){const r=p(t);let i=function(t,e,n){const o=["left","right"],r=["right","left"],i=["top","bottom"],s=["bottom","top"];switch(t){case"top":case"bottom":return n?e?r:o:e?o:r;case"left":case"right":return e?i:s;default:return[]}}(m(t),"start"===n,o);return r&&(i=i.map((t=>t+"-"+r)),e&&(i=i.concat(i.map(w)))),i}(s,v,y,E));const S=[s,...D],O=await L(e,A),P=[];let k=(null==(n=r.flip)?void 0:n.overflows)||[];if(a&&P.push(O[R]),f){const t=function(t,e,n){void 0===n&&(n=!1);const o=p(t),r=x(t),i=g(r);let s="x"===r?o===(n?"end":"start")?"right":"left":"start"===o?"bottom":"top";return e.reference[i]>e.floating[i]&&(s=b(s)),[s,b(s)]}(o,i,E);P.push(O[t[0]],O[t[1]])}if(k=[...k,{placement:o,overflows:P}],!P.every((t=>t<=0))){var C,F;const t=((null==(C=r.flip)?void 0:C.index)||0)+1,e=S[t];if(e)return{data:{index:t,overflows:k},reset:{placement:e}};let n=null==(F=k.filter((t=>t.overflows[0]<=0)).sort(((t,e)=>t.overflows[1]-e.overflows[1]))[0])?void 0:F.placement;if(!n)switch(h){case"bestFit":{var H;const t=null==(H=k.map((t=>[t.placement,t.overflows.filter((t=>t>0)).reduce(((t,e)=>t+e),0)])).sort(((t,e)=>t[1]-e[1]))[0])?void 0:H[0];t&&(n=t);break}case"initialPlacement":n=s}if(o!==n)return{reset:{placement:n}}}return{}}}},t.limitShift=function(t){return void 0===t&&(t={}),{options:t,fn(e){const{x:n,y:o,placement:r,rects:i,middlewareData:s}=e,{offset:l=0,mainAxis:c=!0,crossAxis:a=!0}=d(t,e),f={x:n,y:o},u=y(r),p=h(u);let g=f[p],x=f[u];const w=d(l,e),b="number"==typeof w?{mainAxis:w,crossAxis:0}:{mainAxis:0,crossAxis:0,...w};if(c){const t="y"===p?"height":"width",e=i.reference[p]-i.floating[t]+b.mainAxis,n=i.reference[p]+i.reference[t]-b.mainAxis;g<e?g=e:g>n&&(g=n)}if(a){var v,A;const t="y"===p?"width":"height",e=["top","left"].includes(m(r)),n=i.reference[u]-i.floating[t]+(e&&(null==(v=s.offset)?void 0:v[u])||0)+(e?0:b.crossAxis),o=i.reference[u]+i.reference[t]+(e?0:(null==(A=s.offset)?void 0:A[u])||0)-(e?b.crossAxis:0);x<n?x=n:x>o&&(x=o)}return{[p]:g,[u]:x}}}},t.logicalSide=st,t.offset=ot,t.shift=function(t){return void 0===t&&(t={}),{name:"shift",options:t,async fn(e){const{x:n,y:o,placement:r}=e,{mainAxis:i=!0,crossAxis:s=!1,limiter:l={fn:t=>{let{x:e,y:n}=t;return{x:e,y:n}}},...c}=d(t,e),a={x:n,y:o},f=await L(e,c),p=y(m(r)),g=h(p);let x=a[g],w=a[p];if(i){const t="y"===g?"bottom":"right";x=u(x+f["y"===g?"top":"left"],x,x-f[t])}if(s){const t="y"===p?"bottom":"right";w=u(w+f["y"===p?"top":"left"],w,w-f[t])}const b=l.fn({...e,[g]:x,[p]:w});return{...b,data:{x:b.x-n,y:b.y-o}}}}},t.size=function(t){return void 0===t&&(t={}),{name:"size",options:t,async fn(e){const{placement:n,rects:o,platform:s,elements:l}=e,{apply:c=()=>{},...a}=d(t,e),f=await L(e,a),u=m(n),h=p(n),g="y"===y(n),{width:x,height:w}=o.floating;let b,v;"top"===u||"bottom"===u?(b=u,v=h===(await(null==s.isRTL?void 0:s.isRTL(l.floating))?"start":"end")?"left":"right"):(v=u,b="end"===h?"top":"bottom");const A=w-f[b],R=x-f[v],T=!e.middlewareData.shift;let E=A,D=R;if(g){const t=x-f.left-f.right;D=h||T?r(R,t):t}else{const t=w-f.top-f.bottom;E=h||T?r(A,t):t}if(T&&!h){const t=i(f.left,0),e=i(f.right,0),n=i(f.top,0),o=i(f.bottom,0);g?D=x-2*(0!==t||0!==e?t+e:i(f.left,f.right)):E=w-2*(0!==n||0!==o?n+o:i(f.top,f.bottom))}await c({...e,availableWidth:D,availableHeight:E});const S=await s.getDimensions(l.floating);return x!==S.width||w!==S.height?{reset:{rects:!0}}:{}}}},t.useFloating=function({middleware:t,placement:r,strategy:i,onPosition:s,whileElementsMounted:l}){["top","top-start","top-end","top-start-corner","top-end-corner","start","start-top","start-bottom","start-top-corner","start-bottom-corner","bottom","bottom-start","bottom-end","bottom-start-corner","bottom-end-corner","end","end-top","end-bottom","end-top-corner","end-bottom-corner"].includes(r)||(r="bottom");const c=e.useRef(null),a=e.useRef(null),[f,u]=e.useState(null),[d,m]=e.useState(null),p=function(t){const n=e.useRef(t);return e.useLayoutEffect((()=>{n.current=t})),n}(l),h=e.useRef(!1),{direction:g}=n.useUser(),[y,x]=e.useState({x:null,y:null,strategy:i??"absolute",placement:"bottom",middlewareData:{}}),w=e.useRef(y),[b,v]=e.useState(t);it(b,t)||v(t);const A=e.useCallback((()=>{if(!c.current||!a.current)return;const t=((t,e)=>{const n=t.split("-")[0],o=t.split("-")[1];if(null==t.split("-")[2])return{placement:t,offset:void 0};const r=["top-start","start-top","bottom-start","start-bottom","top-end","end-top","bottom-end","end-bottom"].filter((t=>t===`${n}-${o}`))[0];return"start"==o?{placement:r,offset:{crossAxis:-e.offsetWidth}}:"end"==o?{placement:r,offset:{crossAxis:e.offsetWidth}}:"top"==o?{placement:r,offset:{crossAxis:-e.offsetHeight}}:{placement:r,offset:{crossAxis:e.offsetHeight}}})(r,a.current),e=st(t.placement,g),n=b?.map((e=>{if(e&&"offset"===e?.name){if("function"==typeof e.options)return null==t.offset?e:ot(t.offset);const n="number"==typeof e.options?{mainAxis:e.options,crossAxis:0}:e.options;return ot({mainAxis:(n&&n.mainAxis)??0,crossAxis:((t.offset&&t.offset.crossAxis)??0)+((n&&n.crossAxis)??0)})}return e}));nt(c.current,a.current,{middleware:n,placement:e,strategy:i}).then((t=>{if(h.current){if(t.placement!==w.current.placement||t.x!==w.current.x||t.y!==w.current.y||t.middlewareData.arrow?.x!=w.current.middlewareData.arrow?.x||t.middlewareData.arrow?.y!=w.current.middlewareData.arrow?.y||t.middlewareData.arrow?.centerOffset!=w.current.middlewareData.arrow?.centerOffset){const e=n?.find((t=>t&&"offset"===t?.name)),i=e?.options,l=((t,e)=>{const n=t.split("-")[0];if("top"===n||"bottom"===n)return t;const r=t.split("-")[1],i=o.reverseNormalizePosition(n,e),s={start:"top",end:"bottom"},l=null!=r?r.replace(/start|end/g,(t=>s[t])):null,c=["top","top-start","top-end","end","end-top","end-bottom","bottom-start","bottom-end","bottom","start","start-top","start-bottom"].filter((t=>l&&t===`${i}-${l}`||!l&&t===`${i}`))[0];return c||"bottom"})(t.placement,g),c=t.middlewareData.offset,a={placement:l,origPlacement:r,x:t.x,y:t.y,arrow:t.middlewareData.arrow,offset:c,origOffset:i};s?.(a)}(t=>{w.current=t,x(t)})(t)}}))}),[b,r,g,i,s]);e.useLayoutEffect((()=>(h.current=!0,()=>{h.current=!1})),[]),e.useLayoutEffect((()=>{if(f&&d){if(p.current)return p.current(f,d,A);A()}}),[f,d,A,p]);const R=e.useCallback((t=>{c.current!==t&&(c.current=t,u(t))}),[]),L=e.useCallback((t=>{a.current!==t&&(a.current=t,m(t))}),[]),T=e.useMemo((()=>({reference:c,floating:a})),[]);return e.useMemo((()=>({...y,update:A,refs:T,reference:R,floating:L})),[y,A,T,R,L])}}));
+//# sourceMappingURL=useFloating-0bdf9133.js.map

package/amd/useFloating-0bdf9133.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFloating-0bdf9133.js","sources":["../../../../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","../../../../node_modules/@floating-ui/core/dist/floating-ui.core.mjs","../../../../node_modules/@floating-ui/utils/dom/dist/floating-ui.utils.dom.mjs","../../../../node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","../../src/hooks/PRIVATE_useFloating/useFloating.ts"],"sourcesContent":["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    } = 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. This stops `shift()` from taking action, but can\n    // be worked around by calling it again after the `arrow()` if desired.\n    const shouldAddOffset = 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 ? min$1 - center : max - center : 0;\n    return {\n      [axis]: coords[axis] - alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset + alignmentOffset\n      }\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$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      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) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\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 : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor));\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).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","/**\n * @license\n * MIT License\n *\n * Copyright (c) 2021 Floating UI contributors\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nimport { useLayoutEffect, useCallback, useState, useMemo, useRef, MutableRef } from 'preact/hooks';\nimport { useUser } from '../UNSAFE_useUser';\nimport { normalizePosition, reverseNormalizePosition } from '../../utils/PRIVATE_floatingUtils';\nimport {\n  computePosition,\n  offset as floatingOffset,\n  MiddlewareData,\n  Middleware,\n  Placement as FloatingPlacement,\n  MiddlewareArguments,\n  ComputePositionConfig\n} from '@floating-ui/dom';\nimport {\n  Offset,\n  Placement,\n  Rect,\n  PositionData,\n  RtlSide\n} from '../../UNSAFE_Floating/Floating.types';\n\nexport {\n  autoPlacement,\n  flip,\n  hide,\n  shift,\n  limitShift,\n  size,\n  inline,\n  detectOverflow\n} from '@floating-ui/dom';\n\ntype CornerPlacement = {\n  placement: Placement;\n  offset?: { mainAxis?: number; crossAxis?: number };\n};\n\ntype Side = 'top' | 'right' | 'bottom' | 'left';\ntype Strategy = 'absolute' | 'fixed';\ntype SideObject = {\n  [key in Side]: number;\n};\ntype FloatingOffsetValue =\n  | number\n  | {\n      /**\n       * The axis that runs along the side of the floating element.\n       * @default 0\n       */\n      mainAxis?: number;\n      /**\n       * The axis that runs along the alignment of the floating element.\n       * @default 0\n       */\n      crossAxis?: number;\n      /**\n       * When set to a number, overrides the `crossAxis` value for aligned\n       * (non-centered/base) placements and works logically. A positive number\n       * will move the floating element in the direction of the opposite edge\n       * to the one that is aligned, while a negative number the reverse.\n       * @default null\n       */\n      alignmentAxis?: number | null;\n    };\n\nexport const offset = (value?: Offset): Middleware => {\n  return {\n    name: 'offset',\n    options: value,\n\n    async fn(middlewareArguments: MiddlewareArguments) {\n      const newFn = (args: MiddlewareArguments) => {\n        // flip middleware could be called several times, until the right space is found.\n        // Every time flip is called and overflow is detected, a possible next placement\n        // is chosen and the array of middleware (including the offset middleware) is called again\n        // with the chosen next placement.\n        // Here we detect that flip is needed and we should change the offset sign if needed.\n        const overflowsData =\n          args.middlewareData.flip?.overflows != undefined\n            ? args.middlewareData.flip?.overflows[0]\n            : null;\n        let offset;\n        if (overflowsData != null && value != null && typeof value === 'object') {\n          offset = flippedOffset(args.placement, args.initialPlacement, value);\n        }\n        if (!value) {\n          return 0;\n        }\n        const rawValue: FloatingOffsetValue = offset ?? value;\n        return rawValue;\n      };\n\n      return floatingOffset(newFn).fn(middlewareArguments);\n    }\n  };\n};\n\nconst flippedOffset = (\n  placement: FloatingPlacement,\n  initialPlacement: FloatingPlacement,\n  offset: Offset\n): Offset => {\n  const initialSide = initialPlacement.split('-')[0] as RtlSide;\n  const side = placement.split('-')[0] as RtlSide;\n  const initialAlignment = initialPlacement.split('-')[1];\n  const alignment = placement.split('-')[1];\n  // if flipped around crossAxis\n  if (\n    ((initialSide === 'right' || initialSide === 'left') &&\n      initialSide === side &&\n      initialAlignment !== alignment) ||\n    ((initialSide === 'top' || initialSide === 'bottom') &&\n      initialSide === side &&\n      initialAlignment !== alignment)\n  ) {\n    return {\n      mainAxis: offset && typeof offset === 'object' && offset.mainAxis ? offset.mainAxis : 0,\n      crossAxis: offset && typeof offset === 'object' && offset.crossAxis ? -offset.crossAxis : 0\n    };\n  } else {\n    return offset;\n  }\n};\n\ntype ClientRectObject = Rect & SideObject;\nexport type VirtualElement = {\n  getBoundingClientRect(): ClientRectObject;\n  contextElement?: any;\n};\n\ntype ReferenceType = Element | VirtualElement;\ntype UseFloatingProps<RT extends ReferenceType = ReferenceType> = Omit<\n  Partial<ComputePositionConfig>,\n  'platform' | 'placement'\n> & {\n  placement: Placement;\n  whileElementsMounted?: (\n    reference: RT,\n    floating: HTMLElement,\n    update: () => void\n  ) => void | (() => void);\n  onPosition?: (data: PositionData) => void;\n};\n\ntype UseFloatingData = {\n  placement: FloatingPlacement;\n  strategy: Strategy;\n  middlewareData: MiddlewareData;\n  x: number | null;\n  y: number | null;\n};\n\ntype UseFloatingReturn<RT extends ReferenceType = ReferenceType> = UseFloatingData & {\n  update: () => void;\n  reference: (node: RT | null) => void;\n  floating: (node: HTMLElement | null) => void;\n  refs: {\n    reference: MutableRef<RT | null>;\n    floating: MutableRef<HTMLElement | null>;\n  };\n};\n\n// Fork of `fast-deep-equal` that only does the comparisons we need and compares\n// functions\nfunction deepEqual(a: any, b: any) {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== typeof b) {\n    return false;\n  }\n\n  if (typeof a === 'function' && a.toString() === b.toString()) {\n    return true;\n  }\n\n  let length, i, keys;\n\n  if (a && b && typeof a == 'object') {\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0; ) {\n        if (!deepEqual(a[i], b[i])) {\n          return false;\n        }\n      }\n\n      return true;\n    }\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n\n    for (i = length; i-- !== 0; ) {\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {\n        return false;\n      }\n    }\n\n    for (i = length; i-- !== 0; ) {\n      const key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        continue;\n      }\n\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  return a !== a && b !== b;\n}\n\nfunction useLatestRef<T>(value: T) {\n  const ref = useRef(value);\n  useLayoutEffect(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\nconst reverseLogicalSide = (placement: FloatingPlacement, direction: 'rtl' | 'ltr'): Placement => {\n  const side = placement.split('-')[0] as RtlSide;\n  if (side === 'top' || side === 'bottom') {\n    return placement as Placement;\n  }\n  const alignment = placement.split('-')[1];\n  const reversedPhysicalSide = reverseNormalizePosition(side, direction);\n  const alignmentSideHash = {\n    start: 'top',\n    end: 'bottom'\n  };\n  const alignmentMappedSide =\n    alignment != null\n      ? alignment.replace(/start|end/g, (matched) => (alignmentSideHash as any)[matched])\n      : null;\n\n  const placements: Array<Placement> = [\n    'top',\n    'top-start',\n    'top-end',\n    'end',\n    'end-top',\n    'end-bottom',\n    'bottom-start',\n    'bottom-end',\n    'bottom',\n    'start',\n    'start-top',\n    'start-bottom'\n  ];\n\n  const newPlacement: Placement = placements.filter(\n    (placement) =>\n      (alignmentMappedSide && placement === `${reversedPhysicalSide}-${alignmentMappedSide}`) ||\n      (!alignmentMappedSide && placement === `${reversedPhysicalSide}`)\n  )[0];\n  if (!newPlacement) {\n    return 'bottom';\n  }\n\n  return newPlacement;\n};\n\nexport const logicalSide = (placement: Placement, direction: 'rtl' | 'ltr'): FloatingPlacement => {\n  const side = placement.split('-')[0] as RtlSide;\n  const alignment = placement.split('-')[1];\n  const physicalSide = normalizePosition(side, direction);\n\n  let alignmentSideHash: any;\n  let alignmentMappedSide: string;\n  if (alignment) {\n    alignmentSideHash = {\n      top: 'start',\n      bottom: 'end'\n    };\n\n    alignmentMappedSide = alignment.replace(\n      /top|bottom/g,\n      (matched) => (alignmentSideHash as any)[matched]\n    );\n  }\n\n  const placements: Array<FloatingPlacement> = [\n    'top',\n    'right',\n    'bottom',\n    'left',\n    'top-start',\n    'right-start',\n    'bottom-start',\n    'left-start',\n    'top-end',\n    'right-end',\n    'bottom-end',\n    'left-end'\n  ];\n  const newPlacement: FloatingPlacement = placements.filter(\n    (placement) =>\n      (alignmentMappedSide && placement === `${physicalSide}-${alignmentMappedSide}`) ||\n      (!alignmentMappedSide && placement === `${physicalSide}`)\n  )[0];\n  if (!newPlacement) {\n    return 'bottom';\n  }\n\n  return newPlacement;\n};\n\nconst cornerPlacement = (placement: Placement, floating: HTMLElement): CornerPlacement => {\n  const side = placement.split('-')[0];\n  const alignment = placement.split('-')[1];\n  const corner = placement.split('-')[2];\n  if (corner == null) {\n    return { placement: placement, offset: undefined };\n  }\n\n  const placements: Array<Placement> = [\n    'top-start',\n    'start-top',\n    'bottom-start',\n    'start-bottom',\n    'top-end',\n    'end-top',\n    'bottom-end',\n    'end-bottom'\n  ];\n  const newPlacement: Placement = placements.filter(\n    (placement) => placement === `${side}-${alignment}`\n  )[0];\n  if (alignment == 'start') {\n    return { placement: newPlacement, offset: { crossAxis: -floating.offsetWidth } };\n  }\n  if (alignment == 'end') {\n    return { placement: newPlacement, offset: { crossAxis: floating.offsetWidth } };\n  }\n  if (alignment == 'top') {\n    return { placement: newPlacement, offset: { crossAxis: -floating.offsetHeight } };\n  }\n  // the last option should always be alignment == 'bottom'\n  return { placement: newPlacement, offset: { crossAxis: floating.offsetHeight } };\n};\n\nconst isOfPlacementType = (value: string): boolean => {\n  const placementTypeValues = [\n    'top',\n    'top-start',\n    'top-end',\n    'top-start-corner',\n    'top-end-corner',\n    'start',\n    'start-top',\n    'start-bottom',\n    'start-top-corner',\n    'start-bottom-corner',\n    'bottom',\n    'bottom-start',\n    'bottom-end',\n    'bottom-start-corner',\n    'bottom-end-corner',\n    'end',\n    'end-top',\n    'end-bottom',\n    'end-top-corner',\n    'end-bottom-corner'\n  ];\n\n  return placementTypeValues.includes(value);\n};\n\nexport function useFloating<RT extends ReferenceType = ReferenceType>({\n  middleware,\n  placement,\n  strategy,\n  onPosition,\n  whileElementsMounted\n}: UseFloatingProps): UseFloatingReturn<RT> {\n  //this should not happen, checking to just to be safe\n  if (!isOfPlacementType(placement)) {\n    placement = 'bottom';\n  }\n  const referenceRef = useRef<RT | null>(null);\n  const floatingRef = useRef<HTMLElement | null>(null);\n\n  const [reference, _setReference] = useState<RT | null>(null);\n  const [floating, _setFloating] = useState<HTMLElement | null>(null);\n\n  const whileElementsMountedRef = useLatestRef(whileElementsMounted);\n  const isMountedRef = useRef(false);\n  const { direction } = useUser();\n\n  const [data, _setData] = useState<UseFloatingData>({\n    // Setting these to `null` will allow the consumer to determine if\n    // `computePosition()` has run yet\n    x: null,\n    y: null,\n    strategy: strategy ?? 'absolute',\n    placement: 'bottom',\n    middlewareData: {}\n  });\n  const dataRef = useRef(data);\n  const setData = (data: UseFloatingData) => {\n    dataRef.current = data;\n    _setData(data);\n  };\n\n  const [latestMiddleware, setLatestMiddleware] = useState(middleware);\n\n  if (!deepEqual(latestMiddleware, middleware)) {\n    setLatestMiddleware(middleware);\n  }\n\n  const update = useCallback(() => {\n    if (!referenceRef.current || !floatingRef.current) {\n      return;\n    }\n\n    // map *-corner placement to normalized placement and offset\n    const floatingCornerPlacement: CornerPlacement = cornerPlacement(\n      placement,\n      floatingRef.current\n    );\n    // map start/end placements to right/left depending on the reading direction\n    const floatingUiPlacement: FloatingPlacement = logicalSide(\n      floatingCornerPlacement.placement,\n      direction\n    );\n\n    // we need a summarized offset middleware\n    const newMiddlewareArray: Array<Middleware | null | undefined | false> | undefined =\n      latestMiddleware?.map((m: Middleware | null | undefined | false) => {\n        if (m && m?.name === 'offset') {\n          if (typeof m.options === 'function') {\n            // ignore function if there are *-corner placements\n            return floatingCornerPlacement.offset == null\n              ? m\n              : offset(floatingCornerPlacement.offset);\n          }\n\n          const currentOffset =\n            typeof m.options === 'number' ? { mainAxis: m.options, crossAxis: 0 } : m.options;\n          return offset({\n            mainAxis: (currentOffset && currentOffset.mainAxis) ?? 0,\n            crossAxis:\n              ((floatingCornerPlacement.offset && floatingCornerPlacement.offset.crossAxis) ?? 0) +\n              ((currentOffset && currentOffset.crossAxis) ?? 0)\n          });\n        } else {\n          return m;\n        }\n      });\n    computePosition(referenceRef.current, floatingRef.current, {\n      middleware: newMiddlewareArray,\n      placement: floatingUiPlacement,\n      strategy\n    }).then((newData) => {\n      if (isMountedRef.current) {\n        if (\n          newData.placement !== dataRef.current.placement ||\n          newData.x !== dataRef.current.x ||\n          newData.y !== dataRef.current.y ||\n          newData.middlewareData.arrow?.x != dataRef.current.middlewareData.arrow?.x ||\n          newData.middlewareData.arrow?.y != dataRef.current.middlewareData.arrow?.y ||\n          newData.middlewareData.arrow?.centerOffset !=\n            dataRef.current.middlewareData.arrow?.centerOffset\n        ) {\n          const newMiddleware = newMiddlewareArray?.find(\n            (m) => m && m?.name === 'offset'\n          ) as Middleware;\n          const origOffset = newMiddleware?.options;\n          const reversedNewPlacement = reverseLogicalSide(newData.placement, direction);\n          const offset = newData.middlewareData.offset;\n          const mappedData = {\n            // we need to map right/left, returned from the computePosition, to start/end\n            placement: reversedNewPlacement,\n            origPlacement: placement,\n            x: newData.x,\n            y: newData.y,\n            arrow: newData.middlewareData.arrow,\n            offset: offset,\n            origOffset: origOffset\n          };\n          onPosition?.(mappedData);\n        }\n        setData(newData);\n      }\n    });\n  }, [latestMiddleware, placement, direction, strategy, onPosition]);\n\n  useLayoutEffect(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n\n  useLayoutEffect(() => {\n    if (reference && floating) {\n      if (whileElementsMountedRef.current) {\n        return whileElementsMountedRef.current(reference, floating, update);\n      } else {\n        update();\n      }\n    }\n  }, [reference, floating, update, whileElementsMountedRef]);\n\n  const setReference = useCallback((node: RT | null) => {\n    if (referenceRef.current !== node) {\n      referenceRef.current = node;\n      _setReference(node);\n    }\n  }, []);\n\n  const setFloating = useCallback((node: HTMLElement | null) => {\n    if (floatingRef.current !== node) {\n      floatingRef.current = node;\n      _setFloating(node);\n    }\n  }, []);\n\n  const refs = useMemo(() => ({ reference: referenceRef, floating: floatingRef }), []);\n\n  return useMemo(\n    () => ({\n      ...data,\n      update,\n      refs,\n      reference: setReference,\n      floating: setFloating\n    }),\n    [data, update, refs, setReference, setFloating]\n  );\n}\n"],"names":["min","Math","max","round","floor","createCoords","v","x","y","oppositeSideMap","left","right","bottom","top","oppositeAlignmentMap","start","end","clamp","value","evaluate","param","getSide","placement","split","getAlignment","getOppositeAxis","axis","getAxisLength","getSideAxis","includes","getAlignmentAxis","getOppositeAlignmentPlacement","replace","alignment","getOppositePlacement","side","getPaddingObject","padding","expandPaddingObject","rectToClientRect","rect","width","height","computeCoordsFromPlacement","_ref","rtl","reference","floating","sideAxis","alignmentAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","async","detectOverflow","state","options","_await$platform$isEle","platform","rects","elements","strategy","boundary","rootBoundary","elementContext","altBoundary","paddingObject","element","clippingClientRect","getClippingRect","isElement","contextElement","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","offset","name","fn","diffCoords","isRTL","mainAxisMulti","crossAxisMulti","rawValue","mainAxis","crossAxis","convertValueToCoords","data","getNodeName","node","isNode","nodeName","toLowerCase","getWindow","_node$ownerDocument","ownerDocument","defaultView","window","document","documentElement","Node","Element","isHTMLElement","HTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","overflow","overflowX","overflowY","display","getComputedStyle","test","isTableElement","isContainingBlock","webkit","isWebKit","css","transform","perspective","containerType","backdropFilter","filter","some","willChange","contain","CSS","supports","isLastTraversableNode","getNodeScroll","scrollLeft","scrollTop","pageXOffset","pageYOffset","getParentNode","result","assignedSlot","parentNode","host","getNearestOverflowAncestor","body","getOverflowAncestors","list","_node$ownerDocument2","scrollableAncestor","isBody","win","concat","visualViewport","getCssDimensions","parseFloat","hasOffset","offsetWidth","offsetHeight","shouldFallback","$","unwrapElement","domElement","getBoundingClientRect","Number","isFinite","noOffsets","getVisualOffsets","offsetLeft","offsetTop","includeScale","isFixedStrategy","clientRect","scale","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","offsetWin","currentIFrame","frameElement","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getWindowScrollBarX","getClientRectFromClippingAncestor","clippingAncestor","html","clientWidth","clientHeight","visualViewportBased","getViewportRect","scroll","scrollWidth","scrollHeight","direction","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","position","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","getTrueOffsetParent","polyfill","currentNode","getContainingBlock","clippingAncestors","cache","cachedResult","get","el","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","ancestor","set","getClippingElementAncestors","this","_c","firstClippingAncestor","clippingRect","reduce","accRect","getElementRects","getOffsetParentFn","getDimensionsFn","getDimensions","getClientRects","Array","from","computePosition","Map","mergedOptions","platformWithCache","config","middleware","validMiddleware","Boolean","statefulPlacement","middlewareData","resetCount","i","length","nextX","nextY","reset","initialPlacement","computePosition$1","middlewareArguments","floatingOffset","args","undefined","flip","overflows","flippedOffset","initialSide","initialAlignment","deepEqual","a","b","toString","keys","isArray","Object","prototype","hasOwnProperty","call","key","$$typeof","logicalSide","physicalSide","normalizePosition","alignmentSideHash","alignmentMappedSide","matched","newPlacement","arrowDimensions","isYAxis","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","alignmentOffset","centerOffset","update","ancestorScroll","ancestorResize","elementResize","ResizeObserver","layoutShift","IntersectionObserver","animationFrame","referenceEl","ancestors","forEach","addEventListener","passive","cleanupIo","onMove","timeoutId","io","root","cleanup","clearTimeout","disconnect","refresh","skip","threshold","rootMargin","isFirstUpdate","handleObserve","entries","ratio","intersectionRatio","setTimeout","e","observe","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","target","unobserve","cancelAnimationFrame","requestAnimationFrame","prevRefRect","frameLoop","nextRefRect","removeEventListener","_middlewareData$flip","checkMainAxis","checkCrossAxis","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","detectOverflowOptions","isBasePlacement","oppositePlacement","getExpandedPlacements","push","isStart","lr","rl","tb","bt","getSideList","map","getOppositeAxisPlacements","placements","overflowsData","sides","mainAlignmentSide","getAlignmentSides","every","_middlewareData$flip2","_overflowsData$filter","nextIndex","index","nextPlacement","resetPlacement","d","sort","_overflowsData$map$so","acc","mainAxisCoord","crossAxisCoord","rawOffset","computedOffset","len","limitMin","limitMax","_middlewareData$offse","_middlewareData$offse2","isOriginSide","limiter","maxSide","limitedCoords","apply","heightSide","widthSide","overflowAvailableHeight","overflowAvailableWidth","noShift","shift","availableHeight","availableWidth","maximumClippingWidth","maximumClippingHeight","xMin","xMax","yMin","yMax","nextDimensions","onPosition","whileElementsMounted","referenceRef","useRef","floatingRef","_setReference","useState","_setFloating","whileElementsMountedRef","ref","useLayoutEffect","current","useLatestRef","isMountedRef","useUser","_setData","dataRef","latestMiddleware","setLatestMiddleware","useCallback","floatingCornerPlacement","cornerPlacement","floatingUiPlacement","newMiddlewareArray","m","currentOffset","then","newData","arrow","newMiddleware","find","origOffset","reversedNewPlacement","reversedPhysicalSide","reverseNormalizePosition","reverseLogicalSide","mappedData","origPlacement","setData","setReference","setFloating","refs","useMemo"],"mappings":"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"}

package/amd/useHiddenTestMethod-6bbe8a43.js

@@ -0,0 +1,2 @@
+define(['exports', 'preact/hooks', './LayerHost-1a734852', 'preact/jsx-runtime', 'preact/compat'], (function(e,t,n,o,r){"use strict";e.useHiddenTestMethod=function({elementRef:e,method:o,name:r}){const c=t.useContext(n.EnvironmentContext);t.useEffect((()=>{e.current&&"production"!==c.mode&&(e.current[r]=o)}),[c.mode,e,o,r])}}));
+//# sourceMappingURL=useHiddenTestMethod-6bbe8a43.js.map

package/amd/useHiddenTestMethod-6bbe8a43.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHiddenTestMethod-6bbe8a43.js","sources":["../../src/hooks/UNSAFE_useHiddenTestMethod/useHiddenTestMethod.ts"],"sourcesContent":["import { RefObject } from 'preact';\nimport { useEffect } from 'preact/hooks';\nimport { EnvironmentContext } from '../../UNSAFE_Environment';\nimport { useContext } from 'preact/hooks';\n\ntype UseHiddenTestMethodProps = {\n  elementRef: RefObject<HTMLElement>;\n  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */\n  method: (...args: any[]) => void;\n  name: string;\n};\n\n/**\n * This hook is used to add a hidden method to a component's root DOM element\n * that can be called by test adapters. The hidden method is only added when\n * we are not running in production mode, i.e. it's only used for testing.\n *\n * @param elementRef The ref to a component's root DOM element\n * @param method The hidden method to expose in the DOM\n * @param name The name of the hidden method in the DOM\n */\nexport function useHiddenTestMethod({ elementRef, method, name }: UseHiddenTestMethodProps) {\n  const context = useContext(EnvironmentContext);\n\n  // Add the hidden method to the DOM element only when mode !== production.\n  useEffect(() => {\n    if (elementRef.current && context.mode !== 'production') {\n      /* eslint-disable-next-line @typescript-eslint/no-explicit-any */\n      (elementRef.current as any)[name] = method;\n    }\n  }, [context.mode, elementRef, method, name]);\n}\n"],"names":["elementRef","method","name","context","useContext","EnvironmentContext","useEffect","current","mode"],"mappings":"sJAqBM,UAA8BA,WAAEA,EAAUC,OAAEA,EAAMC,KAAEA,IACxD,MAAMC,EAAUC,aAAWC,EAAAA,oBAG3BC,EAAAA,WAAU,KACJN,EAAWO,SAA4B,eAAjBJ,EAAQK,OAE/BR,EAAWO,QAAgBL,GAAQD,EACrC,GACA,CAACE,EAAQK,KAAMR,EAAYC,EAAQC,GACxC"}