@atlaskit/top-layer 0.9.0 → 0.10.0

package/dist/cjs/use-arrow-navigation/use-arrow-navigation.js

@@ -14,16 +14,16 @@ var menuScope = '[role="menu"]';
 
 /**
  * Returns true if the element belongs to the current menu level of the
- * container — i.e. it is NOT inside a nested `role="menu"` sub-container.
+ * container, i.e. it is NOT inside a nested `role="menu"` sub-container.
  *
  * Uses `element.closest('[role="menu"]')` to determine the nearest menu
  * scope. If the nearest scope is the container's own `role="menu"` element,
- * the element belongs to this level. If it's a different (nested) menu,
+ * the element belongs to this level. If it is a different (nested) menu,
  * the element belongs to a child level and should be excluded.
  *
  * Supports two container patterns:
  *
- * **1. Container has `role="menu"` directly** (preferred — used by avatar-group):
+ * **1. Container has `role="menu"` directly** (preferred, used by avatar-group):
  *   ```
  *   <div ref={containerRef} role="menu">
  *     <button role="menuitem" />   ← isAtCurrentMenuLevel → true
@@ -35,7 +35,7 @@ var menuScope = '[role="menu"]';
  *   Uses the simple check: `element.closest('[role="menu"]') === container`
  *
  * **2. Container is a wrapper without `role="menu"`** (used by dropdown-menu,
- *   where `MenuGroup` owns `role="menu"` but doesn't accept a ref):
+ *   where `MenuGroup` owns `role="menu"` but does not accept a ref):
  *   ```
  *   <div ref={containerRef}>         ← wrapper (no role="menu")
  *     <MenuGroup role="menu">
@@ -62,7 +62,7 @@ var menuScope = '[role="menu"]';
 function isAtCurrentMenuLevel(element, container) {
   var closestMenu = element.closest(menuScope);
 
-  // Container itself has role="menu" — element belongs to this level
+  // Container itself has role="menu". Element belongs to this level
   // if its closest menu is the container.
   if (container.getAttribute('role') === 'menu') {
     return closestMenu === container;
@@ -71,18 +71,18 @@ function isAtCurrentMenuLevel(element, container) {
   // Container is a wrapper without role="menu" (e.g. dropdown-menu
   // wraps a MenuGroup). The element belongs to the top level if its
   // closest role="menu" ancestor is a direct child of the container,
-  // i.e. there's no nested role="menu" between them.
+  // i.e. there is no nested role="menu" between them.
   if (closestMenu === null) {
     return true;
   }
 
-  // Walk up from the closest menu to see if it's "owned" by this
+  // Walk up from the closest menu to see if it is "owned" by this
   // container without passing through another role="menu" first.
   var parent = closestMenu.parentElement;
   while (parent && parent !== container) {
     if (parent.getAttribute('role') === 'menu') {
-      // There's a parent menu between the closest menu and the
-      // container — the element is in a nested sub-menu.
+      // There is a parent menu between the closest menu and the
+      // container, so the element is in a nested sub-menu.
       return false;
     }
     parent = parent.parentElement;
@@ -91,6 +91,22 @@ function isAtCurrentMenuLevel(element, container) {
   // The closest menu is directly inside the container (no nesting).
   return parent === container;
 }
+
+/**
+ * Args for `useArrowNavigation`.
+ *
+ * Keyboard contract:
+ * - `ArrowDown` / `ArrowUp` move within the current menu level.
+ * - `Home` / `End` jump to first / last.
+ * - `ArrowRight` / `ArrowLeft` opens / closes nested submenus.
+ * - `Tab` / `Shift+Tab` dismiss the menu (matching the ARIA APG menu pattern,
+ *   plus Radix UI / Headless UI / React Aria / Floating UI conventions).
+ *   Symmetric in both directions: there is no special-case for the last
+ *   item that lets Tab leave the menu without dismissing it.
+ * - `Page Up` / `Page Down`: NOT handled - extend via your own listener if
+ *   your menu needs page-style scrolling.
+ */
+
 /**
  * Provides arrow key navigation for menu containers.
  *
@@ -222,7 +238,7 @@ function useArrowNavigation(_ref) {
       if (onNestedClose) {
         var _container$parentElem;
         // Only close if this container is inside another role="menu"
-        // (i.e. it's a submenu, not the top-level menu).
+        // (i.e. it is a submenu, not the top-level menu).
         // Walk up from the parent to avoid matching the container itself.
         var isNested = ((_container$parentElem = container.parentElement) === null || _container$parentElem === void 0 ? void 0 : _container$parentElem.closest(menuScope)) !== null;
         if (isNested) {

package/dist/es2019/animations/presets.js

@@ -1,4 +1,4 @@
-import { getPlacement } from '../internal/use-anchor-position';
+import { getPlacement } from '../internal/resolve-placement';
 
 // ── slideAndFade ──
 
@@ -297,8 +297,10 @@ const DIALOG_SLIDE_UP_AND_FADE_CSS = `
 export function dialogSlideUpAndFade(options) {
   var _options$distance2;
   const distance = (_options$distance2 = options === null || options === void 0 ? void 0 : options.distance) !== null && _options$distance2 !== void 0 ? _options$distance2 : 12;
+
+  // Bare preset name; `Dialog` prefixes it via `data-ds-dialog-{name}`.
   return {
-    name: distance === 12 ? 'dialog-slide-up-and-fade' : `dialog-slide-up-and-fade-${distance}`,
+    name: distance === 12 ? 'slide-up-and-fade' : `slide-up-and-fade-${distance}`,
     css: distance === 12 ? DIALOG_SLIDE_UP_AND_FADE_CSS : DIALOG_SLIDE_UP_AND_FADE_CSS.replace(/12px/g, `${distance}px`),
     exitDurationMs: 175
   };
@@ -371,8 +373,9 @@ const DIALOG_FADE_CSS = `
  */
 // eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
 export function dialogFade() {
+  // Bare preset name; `Dialog` prefixes it via `data-ds-dialog-{name}`.
   return {
-    name: 'dialog-fade',
+    name: 'fade',
     css: DIALOG_FADE_CSS,
     exitDurationMs: 175
   };

package/dist/es2019/arrow/index.js

@@ -0,0 +1,269 @@
+import once from '@atlaskit/ds-lib/once';
+import { getPlacement } from '../internal/resolve-placement';
+import { placementToPositionArea } from '../internal/use-anchor-position';
+/**
+ * CSS for popover arrows using the `clip-path: inset() margin-box` technique.
+ *
+ * How it works:
+ * 1. Four arrow shapes exist simultaneously as `::before` (top/bottom) and
+ *    `::after` (left/right) hexagonal pseudo-elements.
+ * 2. `clip-path: inset(0) margin-box` clips the popover to its margin-box.
+ * 3. Margin on the anchor-facing side pushes the popover away, creating space
+ *    where one arrow "escapes" the clip boundary and becomes visible.
+ * 4. `@position-try` rules change both `position-area` and `margin` when
+ *    flipping, ensuring the correct arrow is always shown.
+ *
+ * Constraints:
+ * - `box-shadow` must be `none` (interferes with `clip-path: inset() margin-box`)
+ * - `::before` and `::after` are consumed - consumers cannot use them
+ * - Arrow pseudo-elements use `background: inherit` from the popover element
+ *
+ * @see https://goulet.dev/posts/tooltip-with-popover-and-anchor-positioning/
+ */
+const ARROW_CSS = `
+[data-ds-popover-arrow] {
+  clip-path: inset(var(--ds-arrow-offset, 0px)) margin-box;
+  box-shadow: none;
+}
+
+/* Top and Bottom arrows (vertical hexagon) */
+[data-ds-popover-arrow]::before {
+  content: "";
+  position: absolute;
+  z-index: -1;
+  background: inherit;
+  left: 50%;
+  transform: translateX(-50%);
+  width: calc(var(--ds-arrow-size, 8px) * 2);
+  height: calc(100% + var(--ds-arrow-size, 8px) * 2);
+  top: calc(var(--ds-arrow-size, 8px) * -1);
+  clip-path: polygon(
+    0 var(--ds-arrow-size, 8px),
+    50% 0,
+    100% var(--ds-arrow-size, 8px),
+    100% calc(100% - var(--ds-arrow-size, 8px)),
+    50% 100%,
+    0 calc(100% - var(--ds-arrow-size, 8px))
+  );
+}
+
+/* Left and Right arrows (horizontal hexagon) */
+[data-ds-popover-arrow]::after {
+  content: "";
+  position: absolute;
+  z-index: -1;
+  background: inherit;
+  top: 50%;
+  transform: translateY(-50%);
+  height: calc(var(--ds-arrow-size, 8px) * 2);
+  width: calc(100% + var(--ds-arrow-size, 8px) * 2);
+  left: calc(var(--ds-arrow-size, 8px) * -1);
+  clip-path: polygon(
+    var(--ds-arrow-size, 8px) 0,
+    calc(100% - var(--ds-arrow-size, 8px)) 0,
+    100% 50%,
+    calc(100% - var(--ds-arrow-size, 8px)) 100%,
+    var(--ds-arrow-size, 8px) 100%,
+    0 50%
+  );
+}
+
+/* ── @position-try rules ──
+ * One rule per possible position-area value.
+ * Each sets the position-area and the correct margin direction
+ * so the arrow on the anchor-facing side is revealed.
+ *
+ * Margin direction per edge:
+ *   block-start  (above anchor) → margin-block-end   (bottom, facing anchor)
+ *   block-end    (below anchor) → margin-block-start  (top, facing anchor)
+ *   inline-start (left of anchor) → margin-inline-end (right, facing anchor)
+ *   inline-end   (right of anchor) → margin-inline-start (left, facing anchor)
+ */
+
+/* Each rule sets two margins: the anchor-facing margin for the gap
+   (via --ds-arrow-size) and one cross-axis margin for the shift
+   (via one of --ds-cross-axis-shift-margin-start, --ds-cross-axis-shift-margin-end,
+   --ds-cross-axis-shift-margin-block-start, or --ds-cross-axis-shift-margin-block-end). The
+   side matches the popover's anchored cross-axis edge per align. Only
+   one of the four properties is non-zero at a time; useAnchorPosition
+   picks it. See notes/architecture/positioning.md for details. */
+/* Single-axis centered (align: center) */
+@position-try --ds-arrow-block-start {
+  position-area: block-start;
+  margin: 0;
+  margin-block-end: var(--ds-arrow-size, 8px);
+  margin-inline-start: var(--ds-cross-axis-shift-margin-start, 0px);
+}
+@position-try --ds-arrow-block-end {
+  position-area: block-end;
+  margin: 0;
+  margin-block-start: var(--ds-arrow-size, 8px);
+  margin-inline-start: var(--ds-cross-axis-shift-margin-start, 0px);
+}
+@position-try --ds-arrow-inline-start {
+  position-area: inline-start;
+  margin: 0;
+  margin-inline-end: var(--ds-arrow-size, 8px);
+  margin-block-start: var(--ds-cross-axis-shift-margin-block-start, 0px);
+}
+@position-try --ds-arrow-inline-end {
+  position-area: inline-end;
+  margin: 0;
+  margin-inline-start: var(--ds-arrow-size, 8px);
+  margin-block-start: var(--ds-cross-axis-shift-margin-block-start, 0px);
+}
+
+/* Block edge + inline span (align: start uses span-inline-end; align: end uses span-inline-start) */
+@position-try --ds-arrow-block-start-span-inline-start {
+  position-area: block-start span-inline-start;
+  margin: 0;
+  margin-block-end: var(--ds-arrow-size, 8px);
+  margin-inline-end: var(--ds-cross-axis-shift-margin-end, 0px);
+}
+@position-try --ds-arrow-block-start-span-inline-end {
+  position-area: block-start span-inline-end;
+  margin: 0;
+  margin-block-end: var(--ds-arrow-size, 8px);
+  margin-inline-start: var(--ds-cross-axis-shift-margin-start, 0px);
+}
+@position-try --ds-arrow-block-end-span-inline-start {
+  position-area: block-end span-inline-start;
+  margin: 0;
+  margin-block-start: var(--ds-arrow-size, 8px);
+  margin-inline-end: var(--ds-cross-axis-shift-margin-end, 0px);
+}
+@position-try --ds-arrow-block-end-span-inline-end {
+  position-area: block-end span-inline-end;
+  margin: 0;
+  margin-block-start: var(--ds-arrow-size, 8px);
+  margin-inline-start: var(--ds-cross-axis-shift-margin-start, 0px);
+}
+
+/* Inline edge + block span (align: start uses span-block-end; align: end uses span-block-start) */
+@position-try --ds-arrow-inline-start-span-block-start {
+  position-area: inline-start span-block-start;
+  margin: 0;
+  margin-inline-end: var(--ds-arrow-size, 8px);
+  margin-block-end: var(--ds-cross-axis-shift-margin-block-end, 0px);
+}
+@position-try --ds-arrow-inline-start-span-block-end {
+  position-area: inline-start span-block-end;
+  margin: 0;
+  margin-inline-end: var(--ds-arrow-size, 8px);
+  margin-block-start: var(--ds-cross-axis-shift-margin-block-start, 0px);
+}
+@position-try --ds-arrow-inline-end-span-block-start {
+  position-area: inline-end span-block-start;
+  margin: 0;
+  margin-inline-start: var(--ds-arrow-size, 8px);
+  margin-block-end: var(--ds-cross-axis-shift-margin-block-end, 0px);
+}
+@position-try --ds-arrow-inline-end-span-block-end {
+  position-area: inline-end span-block-end;
+  margin: 0;
+  margin-inline-start: var(--ds-arrow-size, 8px);
+  margin-block-start: var(--ds-cross-axis-shift-margin-block-start, 0px);
+}
+`;
+
+// ── Placement utilities ──
+
+/**
+ * Converts a `position-area` value to a CSS rule name by replacing spaces with hyphens
+ * and prepending `--ds-arrow-`.
+ *
+ * @example positionAreaToRuleName('block-end span-inline-start') → '--ds-arrow-block-end-span-inline-start'
+ */
+function positionAreaToRuleName({
+  positionArea
+}) {
+  return `--ds-arrow-${positionArea.replace(/ /g, '-')}`;
+}
+
+/**
+ * Returns `position-try-fallbacks` using named `@position-try` rules
+ * that change both `position-area` and `margin` when flipping.
+ *
+ * This is required for the arrow technique because built-in keywords
+ * (`flip-block`, `flip-inline`) only flip `position-area` - they do
+ * not update the margin direction needed to reveal the correct arrow.
+ */
+function getTryFallbacks({
+  placement
+}) {
+  const {
+    axis,
+    edge,
+    align
+  } = getPlacement({
+    placement
+  });
+  if (align === 'center') {
+    // Single-axis: only flip the edge
+    const flippedEdge = edge === 'start' ? 'end' : 'start';
+    return positionAreaToRuleName({
+      positionArea: placementToPositionArea({
+        placement: {
+          axis,
+          edge: flippedEdge
+        }
+      })
+    });
+  }
+
+  // Compound placement: try flipping edge, alignment, and both
+  const flippedEdge = edge === 'start' ? 'end' : 'start';
+  const flippedAlign = align === 'start' ? 'end' : 'start';
+  return [positionAreaToRuleName({
+    positionArea: placementToPositionArea({
+      placement: {
+        axis,
+        edge: flippedEdge,
+        align
+      }
+    })
+  }), positionAreaToRuleName({
+    positionArea: placementToPositionArea({
+      placement: {
+        axis,
+        edge,
+        align: flippedAlign
+      }
+    })
+  }), positionAreaToRuleName({
+    positionArea: placementToPositionArea({
+      placement: {
+        axis,
+        edge: flippedEdge,
+        align: flippedAlign
+      }
+    })
+  })].join(', ');
+}
+
+/**
+ * Creates an arrow preset for popover content.
+ *
+ * The returned object is passed to `PopoverContent`'s `arrow` prop.
+ * It carries the CSS string and fallback logic so that consumers who
+ * do not use arrows pay no bundle cost.
+ *
+ * The arrows inherit their background from the popover element.
+ * When `arrow` is active, `PopoverContent` does not reset `background`
+ * to `transparent`, allowing the UA default (`canvas`) or a consumer-set
+ * background to show through.
+ *
+ * @example
+ * ```tsx
+ * import { arrow } from '@atlaskit/top-layer/arrow';
+ *
+ * const myArrow = arrow();
+ *
+ * <Popup.Content arrow={myArrow} />
+ * ```
+ */
+export const arrow = once(() => ({
+  name: 'arrow',
+  css: ARROW_CSS,
+  getTryFallbacks
+}));

package/dist/es2019/arrow/types.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/dialog/dialog-content.js

@@ -15,7 +15,7 @@ const styles = {
 };
 
 /**
- * Low-level `<dialog>` primitive. No visual opinions — no width, height,
+ * Low-level `<dialog>` primitive. No visual opinions - no width, height,
  * background, border-radius, or layout. Consumers provide their own styling.
  *
  * Visibility is controlled declaratively via `isOpen`:
@@ -26,6 +26,10 @@ const styles = {
  *
  * Close flow: we never call `dialog.close()` from event handlers. We always call
  * `onClose`; the consumer decides whether to set `isOpen={false}`.
+ *
+ * Accessibility: render at least one focusable element (typically a close
+ * button) when `isOpen` becomes `true`. Tab is always trapped inside the
+ * dialog, so keyboard users need somewhere to land.
  */
 export const Dialog = /*#__PURE__*/forwardRef(function Dialog({
   children,
@@ -133,11 +137,12 @@ export const Dialog = /*#__PURE__*/forwardRef(function Dialog({
   return /*#__PURE__*/React.createElement("dialog", _extends({
     ref: combinedRef,
     id: dialogId
-    // Modern browsers infer modal semantics from `.showModal()` but
-    // some assistive tech still keys off `aria-modal="true"`. Setting
-    // it explicitly is recommended by WAI-ARIA APG dialog pattern.
+    // `aria-modal` is intentionally NOT set: native `<dialog>.showModal()`
+    // already conveys modal semantics to assistive tech, and double-
+    // declaring it forecloses non-modal use cases (consumers calling
+    // `.show()` would still appear modal). Modern AT (NVDA / JAWS /
+    // VoiceOver) infer modality from the platform accessibility API.
     ,
-    "aria-modal": "true",
     "aria-label": label,
     "aria-labelledby": label ? undefined : labelledBy,
     // eslint-disable-next-line @atlaskit/ui-styling-standard/enforce-style-prop
@@ -145,7 +150,7 @@ export const Dialog = /*#__PURE__*/forwardRef(function Dialog({
     onCancel: handleCancel,
     "data-testid": testId
   }, preset ? {
-    [`data-ds-${preset.name}`]: ''
+    [`data-ds-dialog-${preset.name}`]: ''
   } : undefined, {
     className: ax([styles.dialog])
   }), shouldHideBackdrop &&

package/dist/es2019/entry-points/create-close-event.js

@@ -1,2 +1,9 @@
+/**
+ * @deprecated Combined entry-point retained for backwards-compatibility.
+ * Prefer the disjoint subpaths so that bundle analysis attributes the cost
+ * to the right consumer:
+ *   - `@atlaskit/top-layer/dialog/create-close-event` for `createCloseEvent`
+ *   - `@atlaskit/top-layer/popover/create-close-event` for `createPopoverCloseEvent`
+ */
 export { createCloseEvent } from '../dialog';
 export { createPopoverCloseEvent } from '../popover/create-close-event';

package/dist/es2019/entry-points/dialog/create-close-event.js

@@ -0,0 +1 @@
+export { createCloseEvent } from '../../dialog/create-close-event';

package/dist/es2019/entry-points/placement-map.js

@@ -1 +1,2 @@
-export { fromLegacyPlacement, placementMapping } from '../placement-map';
+export { fromLegacyPlacement } from '../placement-map';
+export { LEGACY_PLACEMENTS } from '../placement-map/legacy-placements';

package/dist/es2019/entry-points/popover/create-close-event.js

@@ -0,0 +1 @@
+export { createPopoverCloseEvent } from '../../popover/create-close-event';

package/dist/es2019/focus/focus.js

@@ -10,6 +10,7 @@
  * restrict which focusable elements are included.
  */
 
+import { getDocument } from '@atlaskit/browser-apis';
 const selectors = (() => {
   // Common exclusion filter applied to every selector.
   const not = ':not([tabindex="-1"]):not([aria-disabled="true"]):not([aria-hidden="true"])';
@@ -17,9 +18,54 @@ const selectors = (() => {
   const focusable = [`a[href]${not}`, `area[href]${not}`, `input${notDisabled}:not([type="hidden"])`, `select${notDisabled}`, `textarea${notDisabled}`, `button${notDisabled}`, `iframe${not}`, `audio[controls]${not}`, `video[controls]${not}`, `[contenteditable]:not([contenteditable="false"])${not}`, `[tabindex]${notDisabled}${not}`];
   return {
     focusable: focusable.join(','),
-    focused: focusable.join(':focus,') + ':focus'
+    // Build the `:focus` selector
+    focused: focusable.map(selector => `${selector}:focus`).join(',')
   };
 })();
+const topLayerSelector = '[popover], dialog, [role="dialog"], [role="alertdialog"]';
+
+/**
+ * Returns true when `element` and `container` resolve to the same nearest
+ * top-layer host (or both resolve to `null`, meaning the document layer).
+ */
+function isInSameLayer({
+  element,
+  container
+}) {
+  const elementLayer = element.closest(topLayerSelector);
+  const containerLayer = container.closest(topLayerSelector);
+  // Both elements are in the "document" layer
+  if (!elementLayer && !containerLayer) {
+    return true;
+  }
+  return elementLayer === containerLayer;
+}
+
+/**
+ * Returns `true` when `document.activeElement` is inside a nested top-layer
+ * descendant of `container` (a `[popover]`, `<dialog>`, `[role="dialog"]` or
+ * `[role="alertdialog"]` that is itself a descendant of `container`).
+ */
+export function isNestedLayerFocused({
+  container
+}) {
+  var _getDocument;
+  const focused = (_getDocument = getDocument()) === null || _getDocument === void 0 ? void 0 : _getDocument.activeElement;
+  if (!(focused instanceof HTMLElement)) {
+    return false;
+  }
+
+  // Cannot be in a nested layer if it is not in the container
+  if (!container.contains(focused)) {
+    return false;
+  }
+
+  // If not in the same layer, must be in a nested layer
+  return !isInSameLayer({
+    element: focused,
+    container
+  });
+}
 
 /**
  * An optional callback to restrict which focusable elements are included.
@@ -29,22 +75,25 @@ const selectors = (() => {
 /**
  * Returns all focusable HTMLElements within the container, optionally filtered.
  *
- * Note: this searches the full subtree and does not stop at nested
- * popover/dialog boundaries. In practice this is fine because nested
- * popovers are not rendered until they are opened, so their content
- * is not in the DOM when the parent's initial focus runs. If that
- * assumption changes, this would need to be scoped to the current layer.
+ * Focusables that belong to a nested top-layer scope (a `[popover]` or
+ * `<dialog>` descendant of the container) are excluded - those elements
+ * are owned by the inner layer's focus management. The container itself
+ * is allowed to be a popover/dialog; only nested ones are filtered.
  */
 function getFocusables({
   container,
   filter
 }) {
-  return Array.from(container.querySelectorAll(selectors.focusable)).filter(element => element instanceof HTMLElement).filter(element => !filter || filter(element, container));
+  return Array.from(container.querySelectorAll(selectors.focusable)).filter(element => element instanceof HTMLElement).filter(element => isInSameLayer({
+    element,
+    container
+  })).filter(element => !filter || filter(element, container));
 }
 
 /**
  * Returns the first focusable element within the container.
  */
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
 export function getFirstFocusable({
   container,
   filter

package/dist/es2019/index.js

@@ -1,7 +1,6 @@
 // This file exists for module resolution purposes.
 // Not exporting anything from the root entry point.
-// Please use individual entry points for minimum bundle size:
 //
-//   import { Popup } from '@atlaskit/top-layer/popup';
-//   import { Dialog } from '@atlaskit/top-layer/dialog';
-//   import { Popover } from '@atlaskit/top-layer/popover';
+// Use individual entry points for minimum bundle size - the full list of
+// available subpaths is the `"exports"` field in this package's
+// `package.json`. The README documents the most common ones.

package/dist/es2019/internal/resolve-css-length-to-pixels.js

@@ -1,3 +1,34 @@
+const elementCaches = new WeakMap();
+function canCacheResolvedLength(value) {
+  // Custom-property values can be retargeted by inline overrides on the
+  // consumer's wrapper, so we cannot prove a cached pixel value is still valid.
+  return !value.includes('var(');
+}
+function getCachedResolvedLength({
+  element,
+  value
+}) {
+  var _cacheForElement$get;
+  if (!canCacheResolvedLength(value)) {
+    return null;
+  }
+  const cacheForElement = elementCaches.get(element);
+  return (_cacheForElement$get = cacheForElement === null || cacheForElement === void 0 ? void 0 : cacheForElement.get(value)) !== null && _cacheForElement$get !== void 0 ? _cacheForElement$get : null;
+}
+function cacheResolvedLength({
+  element,
+  value,
+  result
+}) {
+  var _elementCaches$get;
+  if (!canCacheResolvedLength(value)) {
+    return;
+  }
+  const cacheForElement = (_elementCaches$get = elementCaches.get(element)) !== null && _elementCaches$get !== void 0 ? _elementCaches$get : new Map();
+  cacheForElement.set(value, result);
+  elementCaches.set(element, cacheForElement);
+}
+
 /**
  * Resolves a CSS length value to a pixel number using a hidden DOM probe.
  *
@@ -8,13 +39,11 @@
  * the browser do the math.
  *
  * The probe is appended to `container` so it inherits the same containing
- * block, font size, and custom-property scope as the popover. We use `width`
- * because it accepts any CSS length, including negative `calc()` results
- * (negative widths are clamped to 0 — see note below).
+ * block, font size, and custom-property scope as the popover.
  *
- * Cost: one synchronous reflow per call. The fallback only resolves on
- * placement/offset changes, not on every scroll/resize update, so this is
- * not a hot path.
+ * Cost: one synchronous reflow on first cacheable resolution per
+ * (container, value) pair, then a `WeakMap` lookup. Resolutions involving
+ * `var(` are intentionally not cached.
  */
 export function resolveCssLengthToPixels({
   value,
@@ -24,12 +53,26 @@ export function resolveCssLengthToPixels({
     return value;
   }
 
+  // Fast path: unitless zero is universally zero pixels - accept `'0'` and
+  // `'-0'` without a probe. (Consumers occasionally pass `'0'` instead of
+  // the number `0`.)
+  if (value === '0' || value === '-0') {
+    return 0;
+  }
+
   // Fast path: bare `${n}px` strings come from the consumer normalisation
   // in `getPlacement`. Avoid a reflow when we can.
   const pxMatch = value.match(/^(-?\d+(?:\.\d+)?)px$/);
   if (pxMatch) {
     return Number(pxMatch[1]);
   }
+  const cached = getCachedResolvedLength({
+    element: container,
+    value
+  });
+  if (cached !== null) {
+    return cached;
+  }
   const probe = container.ownerDocument.createElement('div');
   probe.style.position = 'absolute';
   probe.style.visibility = 'hidden';
@@ -41,8 +84,18 @@ export function resolveCssLengthToPixels({
   // preserved. `getComputedStyle` returns the resolved pixel value for
   // margin-* properties even when the source was a token / calc / var.
   probe.style.marginLeft = value;
+  // Hide the probe from assistive tech and event targeting; defensive
+  // against `getElementsByTagName('div')` walks in consumer code.
+  probe.setAttribute('aria-hidden', 'true');
+  probe.setAttribute('inert', '');
   container.appendChild(probe);
   const resolved = parseFloat(getComputedStyle(probe).marginLeft);
   container.removeChild(probe);
-  return Number.isFinite(resolved) ? resolved : 0;
+  const result = Number.isFinite(resolved) ? resolved : 0;
+  cacheResolvedLength({
+    element: container,
+    value,
+    result
+  });
+  return result;
 }