@redvars/peacock 3.5.1 → 3.6.0

package/dist/{navigation-rail-Lxetd5-Z.js → navigation-rail-DyO0oAZU.js}

@@ -1,274 +1,23 @@
 import { a as i, _ as __decorate, i as i$1, b, A, c as __classPrivateFieldGet, w } from './IndividualComponent-DUINtMGK.js';
 import { n } from './property-1psGvXOq.js';
+import { e as e$1 } from './class-map-YU7g0o3B.js';
 import { r } from './state-DwbEjqVk.js';
-import { e as e$1 } from './directive-ZPhl09Yt.js';
-import { e as e$2, o as o$4 } from './unsafe-html-BsGUjx94.js';
-import { e as e$3 } from './class-map-YU7g0o3B.js';
 import { o as observerSlotChangesWithCallback } from './observe-slot-change-BGJfgg2E.js';
-import { a as e, e as e$4 } from './query-QBcUV-L_.js';
+import { a as e, e as e$2 } from './query-QBcUV-L_.js';
 import { B as BaseHyperlinkMixin, t as throttle } from './BaseHyperlinkMixin-BNuwbiEf.js';
-import { o as o$2 } from './style-map-DVmWOuYy.js';
+import { o as o$1 } from './style-map-DVmWOuYy.js';
 import { r as redispatchEvent, i as isActivationClick, d as dispatchActivationClick } from './dispatch-event-utils-CuEqjlPT.js';
-import { s as spread, o as o$3 } from './BaseButton-DuASuVth.js';
-import { B as BaseInput, i as isDarkMode, o as observeThemeChange } from './is-dark-mode-DicqGkCJ.js';
+import { s as spread, o as o$2, a as BaseButtonMixin } from './BaseButton-BNFAYn-S.js';
+import { B as BaseInput } from './BaseInput-14YmcfK7.js';
+import { F as FloatingController } from './popover-NC7b1lTq.js';
+import { i as isDarkMode, o as observeThemeChange } from './is-dark-mode-DOcaw4Yq.js';
+import { o as o$3 } from './unsafe-html-BsGUjx94.js';
 
 /**
  * @license
  * Copyright 2021 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
- */function o$1(o){return (e$1,n)=>{const{slot:r,selector:s}=o??{},c="slot"+(r?`[name=${r}]`:":not([name])");return e(e$1,n,{get(){const t=this.renderRoot?.querySelector(c),e=t?.assignedElements(o)??[];return void 0===s?e:e.filter(t=>t.matches(s))}})}}
-
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */class t extends e$2{}t.directiveName="unsafeSVG",t.resultType=2;const o=e$1(t);
-
-// Basic sanitization: remove <script>, <foreignObject>, event handler attributes (on*), and iframes
-function sanitizeSvg(rawSvg) {
-    try {
-        const parser = new DOMParser();
-        const doc = parser.parseFromString(rawSvg, 'image/svg+xml');
-        const scripts = Array.from(doc.querySelectorAll('script'));
-        scripts.forEach(n => n.remove());
-        const foreigns = Array.from(doc.querySelectorAll('foreignObject, iframe'));
-        foreigns.forEach(n => n.remove());
-        const all = Array.from(doc.querySelectorAll('*'));
-        all.forEach(el => {
-            const attrs = Array.from(el.attributes).filter(a => /^on/i.test(a.name));
-            attrs.forEach(a => el.removeAttribute(a.name));
-        });
-        const el = doc.documentElement;
-        if (!el)
-            return '';
-        const serializer = new XMLSerializer();
-        return serializer.serializeToString(el);
-    }
-    catch (e) {
-        return '';
-    }
-}
-
-async function createCacheFetch(name) {
-    let cache = null;
-    // This map tracks requests currently being processed
-    const inFlightRequests = new Map();
-    try {
-        cache = await window.caches.open(name);
-    }
-    catch (e) {
-        console.warn('window.caches access not allowed');
-    }
-    return async (url) => {
-        if (inFlightRequests.has(url)) {
-            return inFlightRequests.get(url);
-        }
-        const fetchPromise = (async () => {
-            const request = new Request(url);
-            if (cache) {
-                const cachedResponse = await cache.match(request);
-                if (cachedResponse) {
-                    return cachedResponse.text();
-                }
-            }
-            const urlObj = new URL(request.url);
-            const isSameOrigin = urlObj.origin === window.location.origin;
-            const response = await fetch(request.url, {
-                method: 'GET',
-                mode: isSameOrigin ? 'no-cors' : 'cors',
-                credentials: isSameOrigin ? 'same-origin' : 'omit',
-            });
-            if (response.status === 404) {
-                console.error(`[Fetch Error] Resource not found (404): ${url}`);
-                return '';
-            }
-            const result = await response.text();
-            if (cache && response.status === 200) {
-                await cache.put(request, new Response(result, {
-                    status: response.status,
-                    statusText: response.statusText,
-                    headers: response.headers,
-                }));
-            }
-            return result;
-        })();
-        inFlightRequests.set(url, fetchPromise);
-        try {
-            return await fetchPromise;
-        }
-        finally {
-            inFlightRequests.delete(url);
-        }
-    };
-}
-
-const PROVIDERS = {
-    'material-symbols': (name) => `https://cdn.jsdelivr.net/npm/@material-symbols/svg-500@0.40.1/outlined/${name}.svg`,
-    carbon: (name) => `https://cdn.jsdelivr.net/npm/@carbon/icons@11.41.0/svg/32/${name}.svg`,
-};
-const cacheFetch = await createCacheFetch('svg-cache');
-async function fetchSVG(url) {
-    if (!url)
-        return '';
-    return cacheFetch(url);
-}
-async function fetchIcon(name, provider = 'material-symbols') {
-    if (!name)
-        return '';
-    if (!PROVIDERS[provider]) {
-        throw new Error(`Provider '${provider}' not found`);
-    }
-    return fetchSVG(PROVIDERS[provider](name));
-}
-
-var css_248z$S = i`* {
-  box-sizing: border-box;
-}
-
-.screen-reader-only {
-  display: none !important;
-}
-
-:host {
-  display: inline-flex;
-  vertical-align: middle;
-  --icon-size: inherit;
-  --icon-color: inherit;
-}
-
-.icon {
-  height: var(--icon-size, 1rem);
-  width: var(--icon-size, 1rem);
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-}
-.icon svg {
-  fill: var(--icon-color);
-  height: 100%;
-  width: 100%;
-}`;
-
-/**
- * @label Icon
- * @tag wc-icon
- * @rawTag icon
- * @summary Icons are visual symbols used to represent ideas, objects, or actions.
- * @overview Icons are visual symbols used to represent ideas, objects, or actions. They communicate messages at a glance, afford interactivity, and draw attention to important information.
- *
- * @cssprop --icon-color - Controls the color of the icon.
- * @cssprop [--icon-size=1rem] - Controls the size of the icon. Defaults to "1rem"
- *
- * @example
- * ```html
- * <wc-icon name="home" style="--icon-size: 2rem;"></wc-icon>
- * ```
- *
- */
-class Icon extends i$1 {
-    constructor() {
-        super(...arguments);
-        this.provider = 'material-symbols';
-        this.svgContent = '';
-        // loading + error states for consumers/tests
-        this.loading = false;
-        this.error = null;
-        // token to avoid race conditions when multiple fetches overlap
-        this._fetchId = 0;
-    }
-    firstUpdated() {
-        // perform initial fetch once component is connected and rendered
-        this.__scheduleUpdate();
-    }
-    updated(changedProperties) {
-        // only refetch when name or src changed
-        if (changedProperties.has('name') || changedProperties.has('src')) {
-            this.__scheduleUpdate();
-        }
-    }
-    render() {
-        // accessible wrapper; consumers can provide a fallback via <slot name="fallback">.
-        return b ` <div class="icon">
-      ${this.svgContent
-            ? o(this.svgContent)
-            : b `<slot name="fallback"></slot>`}
-    </div>`;
-    }
-    // small debounce to coalesce rapid changes (50ms)
-    __scheduleUpdate() {
-        if (this._debounceTimer) {
-            clearTimeout(this._debounceTimer);
-        }
-        // @ts-ignore - setTimeout in DOM returns number
-        this._debounceTimer = window.setTimeout(() => this.__updateSvg(), 50);
-    }
-    /**
-     * @internal
-     */
-    async __updateSvg() {
-        this._fetchId += 1;
-        const currentId = this._fetchId;
-        this.loading = true;
-        this.error = null;
-        try {
-            let raw;
-            if (this.name) {
-                raw = await fetchIcon(this.name, this.provider);
-            }
-            else if (this.src) {
-                raw = await fetchSVG(this.src);
-            }
-            else {
-                raw = '';
-            }
-            // If another fetch started after this one, ignore this result
-            if (currentId !== this._fetchId)
-                return;
-            if (raw) {
-                this.svgContent = sanitizeSvg(raw);
-            }
-            else {
-                this.svgContent = '';
-            }
-        }
-        catch (err) {
-            // capture and surface error, but avoid throwing
-            this.error = err instanceof Error ? err : new Error(String(err));
-            this.svgContent = '';
-            // bubble an event so consumers can react
-            this.dispatchEvent(new CustomEvent('icon-error', {
-                detail: { name: this.name, src: this.src, error: this.error },
-                bubbles: true,
-                composed: true,
-            }));
-        }
-        finally {
-            // ensure loading is cleared unless another fetch started
-            if (currentId === this._fetchId) {
-                this.loading = false;
-            }
-        }
-    }
-}
-Icon.styles = [css_248z$S];
-__decorate([
-    n({ type: String, reflect: true })
-], Icon.prototype, "name", void 0);
-__decorate([
-    n({ type: String, reflect: true })
-], Icon.prototype, "src", void 0);
-__decorate([
-    n({ type: String })
-], Icon.prototype, "provider", void 0);
-__decorate([
-    r()
-], Icon.prototype, "svgContent", void 0);
-__decorate([
-    r() // @ts-ignore
-], Icon.prototype, "loading", void 0);
-__decorate([
-    r()
-], Icon.prototype, "error", void 0);
+ */function o(o){return (e$1,n)=>{const{slot:r,selector:s}=o??{},c="slot"+(r?`[name=${r}]`:":not([name])");return e(e$1,n,{get(){const t=this.renderRoot?.querySelector(c),e=t?.assignedElements(o)??[];return void 0===s?e:e.filter(t=>t.matches(s))}})}}
 
 var css_248z$R = i`* {
   box-sizing: border-box;
@@ -344,7 +93,7 @@ class Avatar extends i$1 {
     render() {
         return b `<div class="avatar-container">
       <div
-        class=${e$3({
+        class=${e$1({
             avatar: true,
             initials: !this.src,
             image: !!this.src,
@@ -432,7 +181,7 @@ class Badge extends i$1 {
     }
     render() {
         return b `<div
-      class=${e$3({
+      class=${e$1({
             badge: true,
             'has-value': !!this.value,
         })}
@@ -541,7 +290,7 @@ class Divider extends i$1 {
     }
     render() {
         return b `<div
-      class=${e$3({
+      class=${e$1({
             divider: true,
             vertical: this.vertical,
             'slot-has-content': this.slotHasContent,
@@ -874,7 +623,7 @@ class SegmentedButton extends i$1 {
         };
         return b `
       <div
-        class=${e$3(cssClasses)}
+        class=${e$1(cssClasses)}
         role="button"
         tabindex=${this.disabled ? -1 : 0}
         aria-pressed=${this.selected}
@@ -1320,7 +1069,7 @@ class Ripple extends i$1 {
             'hovered': this.hovered,
             'pressed': this.pressed,
         };
-        return b `<div class="surface ${e$3(classes)}"></div>`;
+        return b `<div class="surface ${e$1(classes)}"></div>`;
     }
     update(changedProps) {
         if (changedProps.has('disabled') && this.disabled) {
@@ -1632,7 +1381,7 @@ __decorate([
     r()
 ], Ripple.prototype, "pressed", void 0);
 __decorate([
-    e$4('.surface')
+    e$2('.surface')
 ], Ripple.prototype, "mdRoot", void 0);
 
 var css_248z$K = i`* {
@@ -1876,7 +1625,7 @@ class AccordionItem extends i$1 {
     render() {
         return b `
       <div
-        class=${e$3({
+        class=${e$1({
             'expansion-panel': true,
             open: this.open,
             disabled: this.disabled,
@@ -1951,7 +1700,7 @@ __decorate([
     r()
 ], AccordionItem.prototype, "_hasHeadingSlot", void 0);
 __decorate([
-    e$4('.header-button')
+    e$2('.header-button')
 ], AccordionItem.prototype, "buttonElement", void 0);
 
 var css_248z$J = i`* {
@@ -2091,7 +1840,7 @@ __decorate([
     n({ type: String, reflect: true, attribute: 'display-mode' })
 ], Accordion.prototype, "displayMode", void 0);
 __decorate([
-    o$1({ selector: 'wc-accordion-item' })
+    o({ selector: 'wc-accordion-item' })
 ], Accordion.prototype, "items", void 0);
 
 var css_248z$I = i`* {
@@ -2147,7 +1896,7 @@ var css_248z$I = i`* {
 class Link extends BaseHyperlinkMixin(i$1) {
     render() {
         return b `<a
-      class=${e$3({
+      class=${e$1({
             link: true,
         })}
       href=${this.href}
@@ -2443,7 +2192,7 @@ class Tag extends i$1 {
             [`size-${this.size}`]: true,
         };
         return b `
-      <div class="${e$3(classes)}">
+      <div class="${e$1(classes)}">
         <wc-elevation class="elevation"></wc-elevation>
         <div class="background"></div>
         <div class="outline"></div>
@@ -2739,7 +2488,7 @@ class Chip extends i$1 {
             [`color-${this.color}`]: true,
         };
         return b `
-      <div class="${e$3(classes)}">
+      <div class="${e$1(classes)}">
         <wc-elevation class="elevation"></wc-elevation>
         <div class="background"></div>
         <div class="outline"></div>
@@ -2938,7 +2687,7 @@ class LinearProgress extends BaseProgress {
     render() {
         return b `
       <div
-        class="${e$3({
+        class="${e$1({
             'linear-progress': true,
             indeterminate: this.indeterminate,
             inline: this.inline,
@@ -2962,7 +2711,7 @@ class LinearProgress extends BaseProgress {
             <div class="track track-start"></div>
             <div
               class="active-indicator"
-              style="${o$2({
+              style="${o$1({
             width: `${this.__getPercentageValue()}%`,
         })}"
             ></div>
@@ -3103,7 +2852,7 @@ class CircularProgress extends BaseProgress {
         const offset = circumference - (percentage / 100) * circumference;
         return b `
       <div
-        class="${e$3({
+        class="${e$1({
             'circular-progress': true,
             indeterminate: this.indeterminate,
             inline: this.inline,
@@ -3122,7 +2871,7 @@ class CircularProgress extends BaseProgress {
               cx="8"
               cy="8"
               r="6"
-              style="${o$2({
+              style="${o$1({
             strokeDasharray: `${circumference}`,
             strokeDashoffset: this.indeterminate ? undefined : `${offset}`,
         })}"
@@ -3485,7 +3234,7 @@ __decorate([
     r()
 ], Input.prototype, "dirty", void 0);
 __decorate([
-    e$4('.input-element')
+    e$2('.input-element')
 ], Input.prototype, "inputElement", void 0);
 
 var css_248z$x = i`* {
@@ -3768,7 +3517,7 @@ __decorate([
     r()
 ], UrlField.prototype, "isValid", void 0);
 __decorate([
-    e$4('.url-input')
+    e$2('.url-input')
 ], UrlField.prototype, "inputElement", void 0);
 
 var css_248z$w = i`* {
@@ -4079,7 +3828,7 @@ class Field extends i$1 {
             populated: this.populated,
         };
         return b `
-      <div class=${e$3(classes)}>
+      <div class=${e$1(classes)}>
         ${this.__renderFieldHeader()}
 
         <div class="field-body" @click=${this.__handleClick}>
@@ -4089,7 +3838,7 @@ class Field extends i$1 {
 
           <div class="field-content">
             <div
-              class=${e$3({
+              class=${e$1({
             'slot-start-wrapper': true,
             'has-content': this.slotStartHasContent,
         })}
@@ -4100,7 +3849,7 @@ class Field extends i$1 {
             <div class="input-wrapper">${this.__renderInputSlot()}</div>
 
             <div
-              class=${e$3({
+              class=${e$1({
             'slot-end-wrapper': true,
             'has-content': this.slotEndHasContent,
         })}
@@ -4341,7 +4090,7 @@ class NumberField extends BaseInput {
         label=${this.label}
         ?focused=${this.focused}
         .host=${this}
-        class=${e$3(classes)}
+        class=${e$1(classes)}
       >
         ${this.stepper && !this.disabled
             ? b `<wc-icon-button
@@ -4453,7 +4202,7 @@ __decorate([
     r()
 ], NumberField.prototype, "dirty", void 0);
 __decorate([
-    e$4('.input-element')
+    e$2('.input-element')
 ], NumberField.prototype, "inputElement", void 0);
 
 var css_248z$u = i`* {
@@ -4676,7 +4425,7 @@ __decorate([
     r()
 ], DatePicker.prototype, "dirty", void 0);
 __decorate([
-    e$4('.input-element')
+    e$2('.input-element')
 ], DatePicker.prototype, "inputElement", void 0);
 
 var css_248z$t = i`* {
@@ -4899,7 +4648,7 @@ __decorate([
     r()
 ], TimePicker.prototype, "dirty", void 0);
 __decorate([
-    e$4('.input-element')
+    e$2('.input-element')
 ], TimePicker.prototype, "inputElement", void 0);
 
 var css_248z$s = i`* {
@@ -5118,7 +4867,7 @@ __decorate([
     r()
 ], Textarea.prototype, "dirty", void 0);
 __decorate([
-    e$4('.input-element')
+    e$2('.input-element')
 ], Textarea.prototype, "inputElement", void 0);
 
 var css_248z$r = i`* {
@@ -5426,7 +5175,7 @@ class Switch extends BaseInput {
             'has-content': this.slotHasContent,
         };
         return b `
-      <label class=${e$3(cssClasses)}>
+      <label class=${e$1(cssClasses)}>
         <div
           class="track"
           tabindex=${this.tabindex || 0}
@@ -5500,10 +5249,10 @@ __decorate([
     r()
 ], Switch.prototype, "slotHasContent", void 0);
 __decorate([
-    e$4('.track')
+    e$2('.track')
 ], Switch.prototype, "trackElement", void 0);
 __decorate([
-    e$4('.input-native')
+    e$2('.input-native')
 ], Switch.prototype, "nativeElement", void 0);
 
 var css_248z$q = i`* {
@@ -5901,7 +5650,7 @@ class Checkbox extends i$1 {
             'has-content': this.slotHasContent,
         };
         return b `
-      <label class=${e$3(cssClasses)}>
+      <label class=${e$1(cssClasses)}>
         <div
           id="container"
           class="container"
@@ -6005,10 +5754,10 @@ __decorate([
     r()
 ], Checkbox.prototype, "slotHasContent", void 0);
 __decorate([
-    e$4('.container')
+    e$2('.container')
 ], Checkbox.prototype, "containerElement", void 0);
 __decorate([
-    e$4('.input-native')
+    e$2('.input-native')
 ], Checkbox.prototype, "nativeElement", void 0);
 
 var css_248z$p = i`* {
@@ -6208,7 +5957,7 @@ class Container extends i$1 {
             [`size-${this.size}`]: true,
         };
         return b `
-      <div class=${e$3(wrapperClasses)}>
+      <div class=${e$1(wrapperClasses)}>
         <div class="container">
           <div class="content">
             <slot></slot>
@@ -6368,7 +6117,7 @@ class EmptyState extends i$1 {
         // Resolving asset paths in Lit typically uses import.meta.url or absolute paths
         const illustrationPath = new URL(`./assets/images/empty-state/${this.illustration}.svg`, import.meta.url).href;
         return b `
-      <div class="${e$3(classes)}">
+      <div class="${e$1(classes)}">
         <div class="empty-state-container">
           <div class="illustration">
             <wc-icon class="illustration-svg" src="${illustrationPath}"></wc-icon>
@@ -6408,13 +6157,15 @@ var css_248z$m = i`* {
   display: none !important;
 }
 
+:host(:not([preview])) {
+  position: absolute;
+  top: 0;
+  left: 0;
+}
 :host(:not([preview])) .tooltip {
   pointer-events: none;
   transition: transform var(--duration-short2) ease-in-out, opacity var(--duration-short2) ease-in-out;
   transform: scale(0);
-  position: absolute;
-  top: 0;
-  left: 0;
   opacity: 0;
 }
 :host(:not([preview])) .tooltip.open {
@@ -6475,1571 +6226,6 @@ var css_248z$m = i`* {
   gap: var(--spacing-100);
 }`;
 
-/**
- * Custom positioning reference element.
- * @see https://floating-ui.com/docs/virtual-elements
- */
-
-const min = Math.min;
-const max = Math.max;
-const round = Math.round;
-const floor = Math.floor;
-const createCoords = v => ({
-  x: v,
-  y: v
-});
-const oppositeSideMap = {
-  left: 'right',
-  right: 'left',
-  bottom: 'top',
-  top: 'bottom'
-};
-function clamp(start, value, end) {
-  return max(start, min(value, end));
-}
-function evaluate(value, param) {
-  return typeof value === 'function' ? value(param) : value;
-}
-function getSide(placement) {
-  return placement.split('-')[0];
-}
-function getAlignment(placement) {
-  return placement.split('-')[1];
-}
-function getOppositeAxis(axis) {
-  return axis === 'x' ? 'y' : 'x';
-}
-function getAxisLength(axis) {
-  return axis === 'y' ? 'height' : 'width';
-}
-function getSideAxis(placement) {
-  const firstChar = placement[0];
-  return firstChar === 't' || firstChar === 'b' ? 'y' : 'x';
-}
-function getAlignmentAxis(placement) {
-  return getOppositeAxis(getSideAxis(placement));
-}
-function getAlignmentSides(placement, rects, rtl) {
-  if (rtl === void 0) {
-    rtl = false;
-  }
-  const alignment = getAlignment(placement);
-  const alignmentAxis = getAlignmentAxis(placement);
-  const length = getAxisLength(alignmentAxis);
-  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
-  if (rects.reference[length] > rects.floating[length]) {
-    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
-  }
-  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
-}
-function getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
-}
-function getOppositeAlignmentPlacement(placement) {
-  return placement.includes('start') ? placement.replace('start', 'end') : placement.replace('end', 'start');
-}
-const lrPlacement = ['left', 'right'];
-const rlPlacement = ['right', 'left'];
-const tbPlacement = ['top', 'bottom'];
-const btPlacement = ['bottom', 'top'];
-function getSideList(side, isStart, rtl) {
-  switch (side) {
-    case 'top':
-    case 'bottom':
-      if (rtl) return isStart ? rlPlacement : lrPlacement;
-      return isStart ? lrPlacement : rlPlacement;
-    case 'left':
-    case 'right':
-      return isStart ? tbPlacement : btPlacement;
-    default:
-      return [];
-  }
-}
-function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
-  const alignment = getAlignment(placement);
-  let list = getSideList(getSide(placement), direction === 'start', rtl);
-  if (alignment) {
-    list = list.map(side => side + "-" + alignment);
-    if (flipAlignment) {
-      list = list.concat(list.map(getOppositeAlignmentPlacement));
-    }
-  }
-  return list;
-}
-function getOppositePlacement(placement) {
-  const side = getSide(placement);
-  return oppositeSideMap[side] + placement.slice(side.length);
-}
-function expandPaddingObject(padding) {
-  return {
-    top: 0,
-    right: 0,
-    bottom: 0,
-    left: 0,
-    ...padding
-  };
-}
-function getPaddingObject(padding) {
-  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
-    top: padding,
-    right: padding,
-    bottom: padding,
-    left: padding
-  };
-}
-function rectToClientRect(rect) {
-  const {
-    x,
-    y,
-    width,
-    height
-  } = rect;
-  return {
-    width,
-    height,
-    top: y,
-    left: x,
-    right: x + width,
-    bottom: y + height,
-    x,
-    y
-  };
-}
-
-function computeCoordsFromPlacement(_ref, placement, rtl) {
-  let {
-    reference,
-    floating
-  } = _ref;
-  const sideAxis = getSideAxis(placement);
-  const alignmentAxis = getAlignmentAxis(placement);
-  const alignLength = getAxisLength(alignmentAxis);
-  const side = getSide(placement);
-  const isVertical = sideAxis === 'y';
-  const commonX = reference.x + reference.width / 2 - floating.width / 2;
-  const commonY = reference.y + reference.height / 2 - floating.height / 2;
-  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
-  let coords;
-  switch (side) {
-    case 'top':
-      coords = {
-        x: commonX,
-        y: reference.y - floating.height
-      };
-      break;
-    case 'bottom':
-      coords = {
-        x: commonX,
-        y: reference.y + reference.height
-      };
-      break;
-    case 'right':
-      coords = {
-        x: reference.x + reference.width,
-        y: commonY
-      };
-      break;
-    case 'left':
-      coords = {
-        x: reference.x - floating.width,
-        y: commonY
-      };
-      break;
-    default:
-      coords = {
-        x: reference.x,
-        y: reference.y
-      };
-  }
-  switch (getAlignment(placement)) {
-    case 'start':
-      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
-      break;
-    case 'end':
-      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
-      break;
-  }
-  return coords;
-}
-
-/**
- * Resolves with an object of overflow side offsets that determine how much the
- * element is overflowing a given clipping boundary on each side.
- * - positive = overflowing the boundary by that number of pixels
- * - negative = how many pixels left before it will overflow
- * - 0 = lies flush with the boundary
- * @see https://floating-ui.com/docs/detectOverflow
- */
-async function detectOverflow(state, options) {
-  var _await$platform$isEle;
-  if (options === void 0) {
-    options = {};
-  }
-  const {
-    x,
-    y,
-    platform,
-    rects,
-    elements,
-    strategy
-  } = state;
-  const {
-    boundary = 'clippingAncestors',
-    rootBoundary = 'viewport',
-    elementContext = 'floating',
-    altBoundary = false,
-    padding = 0
-  } = evaluate(options, state);
-  const paddingObject = getPaddingObject(padding);
-  const altContext = elementContext === 'floating' ? 'reference' : 'floating';
-  const element = elements[altBoundary ? altContext : elementContext];
-  const clippingClientRect = rectToClientRect(await platform.getClippingRect({
-    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))),
-    boundary,
-    rootBoundary,
-    strategy
-  }));
-  const rect = elementContext === 'floating' ? {
-    x,
-    y,
-    width: rects.floating.width,
-    height: rects.floating.height
-  } : rects.reference;
-  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
-  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  };
-  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements,
-    rect,
-    offsetParent,
-    strategy
-  }) : rect);
-  return {
-    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
-    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
-    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
-    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
-  };
-}
-
-// Maximum number of resets that can occur before bailing to avoid infinite reset loops.
-const MAX_RESET_COUNT = 50;
-
-/**
- * Computes the `x` and `y` coordinates that will place the floating element
- * next to a given reference element.
- *
- * This export does not have any `platform` interface logic. You will need to
- * write one for the platform you are using Floating UI with.
- */
-const computePosition$1 = async (reference, floating, config) => {
-  const {
-    placement = 'bottom',
-    strategy = 'absolute',
-    middleware = [],
-    platform
-  } = config;
-  const platformWithDetectOverflow = platform.detectOverflow ? platform : {
-    ...platform,
-    detectOverflow
-  };
-  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
-  let rects = await platform.getElementRects({
-    reference,
-    floating,
-    strategy
-  });
-  let {
-    x,
-    y
-  } = computeCoordsFromPlacement(rects, placement, rtl);
-  let statefulPlacement = placement;
-  let resetCount = 0;
-  const middlewareData = {};
-  for (let i = 0; i < middleware.length; i++) {
-    const currentMiddleware = middleware[i];
-    if (!currentMiddleware) {
-      continue;
-    }
-    const {
-      name,
-      fn
-    } = currentMiddleware;
-    const {
-      x: nextX,
-      y: nextY,
-      data,
-      reset
-    } = await fn({
-      x,
-      y,
-      initialPlacement: placement,
-      placement: statefulPlacement,
-      strategy,
-      middlewareData,
-      rects,
-      platform: platformWithDetectOverflow,
-      elements: {
-        reference,
-        floating
-      }
-    });
-    x = nextX != null ? nextX : x;
-    y = nextY != null ? nextY : y;
-    middlewareData[name] = {
-      ...middlewareData[name],
-      ...data
-    };
-    if (reset && resetCount < MAX_RESET_COUNT) {
-      resetCount++;
-      if (typeof reset === 'object') {
-        if (reset.placement) {
-          statefulPlacement = reset.placement;
-        }
-        if (reset.rects) {
-          rects = reset.rects === true ? await platform.getElementRects({
-            reference,
-            floating,
-            strategy
-          }) : reset.rects;
-        }
-        ({
-          x,
-          y
-        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
-      }
-      i = -1;
-    }
-  }
-  return {
-    x,
-    y,
-    placement: statefulPlacement,
-    strategy,
-    middlewareData
-  };
-};
-
-/**
- * Optimizes the visibility of the floating element by flipping the `placement`
- * in order to keep it in view when the preferred placement(s) will overflow the
- * clipping boundary. Alternative to `autoPlacement`.
- * @see https://floating-ui.com/docs/flip
- */
-const flip$1 = function (options) {
-  if (options === void 0) {
-    options = {};
-  }
-  return {
-    name: 'flip',
-    options,
-    async fn(state) {
-      var _middlewareData$arrow, _middlewareData$flip;
-      const {
-        placement,
-        middlewareData,
-        rects,
-        initialPlacement,
-        platform,
-        elements
-      } = state;
-      const {
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = true,
-        fallbackPlacements: specifiedFallbackPlacements,
-        fallbackStrategy = 'bestFit',
-        fallbackAxisSideDirection = 'none',
-        flipAlignment = true,
-        ...detectOverflowOptions
-      } = evaluate(options, state);
-
-      // If a reset by the arrow was caused due to an alignment offset being
-      // added, we should skip any logic now since `flip()` has already done its
-      // work.
-      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643
-      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
-        return {};
-      }
-      const side = getSide(placement);
-      const initialSideAxis = getSideAxis(initialPlacement);
-      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
-      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
-      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';
-      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
-        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
-      }
-      const placements = [initialPlacement, ...fallbackPlacements];
-      const overflow = await platform.detectOverflow(state, detectOverflowOptions);
-      const overflows = [];
-      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
-      if (checkMainAxis) {
-        overflows.push(overflow[side]);
-      }
-      if (checkCrossAxis) {
-        const sides = getAlignmentSides(placement, rects, rtl);
-        overflows.push(overflow[sides[0]], overflow[sides[1]]);
-      }
-      overflowsData = [...overflowsData, {
-        placement,
-        overflows
-      }];
-
-      // One or more sides is overflowing.
-      if (!overflows.every(side => side <= 0)) {
-        var _middlewareData$flip2, _overflowsData$filter;
-        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
-        const nextPlacement = placements[nextIndex];
-        if (nextPlacement) {
-          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== getSideAxis(nextPlacement) : false;
-          if (!ignoreCrossAxisOverflow ||
-          // We leave the current main axis only if every placement on that axis
-          // overflows the main axis.
-          overflowsData.every(d => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
-            // Try next placement and re-run the lifecycle.
-            return {
-              data: {
-                index: nextIndex,
-                overflows: overflowsData
-              },
-              reset: {
-                placement: nextPlacement
-              }
-            };
-          }
-        }
-
-        // First, find the candidates that fit on the mainAxis side of overflow,
-        // then find the placement that fits the best on the main crossAxis side.
-        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;
-
-        // Otherwise fallback.
-        if (!resetPlacement) {
-          switch (fallbackStrategy) {
-            case 'bestFit':
-              {
-                var _overflowsData$filter2;
-                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {
-                  if (hasFallbackAxisSideDirection) {
-                    const currentSideAxis = getSideAxis(d.placement);
-                    return currentSideAxis === initialSideAxis ||
-                    // Create a bias to the `y` side axis due to horizontal
-                    // reading directions favoring greater width.
-                    currentSideAxis === 'y';
-                  }
-                  return true;
-                }).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$filter2[0];
-                if (placement) {
-                  resetPlacement = placement;
-                }
-                break;
-              }
-            case 'initialPlacement':
-              resetPlacement = initialPlacement;
-              break;
-          }
-        }
-        if (placement !== resetPlacement) {
-          return {
-            reset: {
-              placement: resetPlacement
-            }
-          };
-        }
-      }
-      return {};
-    }
-  };
-};
-
-const originSides = /*#__PURE__*/new Set(['left', 'top']);
-
-// For type backwards-compatibility, the `OffsetOptions` type was also
-// Derivable.
-
-async function convertValueToCoords(state, options) {
-  const {
-    placement,
-    platform,
-    elements
-  } = state;
-  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-  const side = getSide(placement);
-  const alignment = getAlignment(placement);
-  const isVertical = getSideAxis(placement) === 'y';
-  const mainAxisMulti = originSides.has(side) ? -1 : 1;
-  const crossAxisMulti = rtl && isVertical ? -1 : 1;
-  const rawValue = evaluate(options, state);
-
-  // eslint-disable-next-line prefer-const
-  let {
-    mainAxis,
-    crossAxis,
-    alignmentAxis
-  } = typeof rawValue === 'number' ? {
-    mainAxis: rawValue,
-    crossAxis: 0,
-    alignmentAxis: null
-  } : {
-    mainAxis: rawValue.mainAxis || 0,
-    crossAxis: rawValue.crossAxis || 0,
-    alignmentAxis: rawValue.alignmentAxis
-  };
-  if (alignment && typeof alignmentAxis === 'number') {
-    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;
-  }
-  return isVertical ? {
-    x: crossAxis * crossAxisMulti,
-    y: mainAxis * mainAxisMulti
-  } : {
-    x: mainAxis * mainAxisMulti,
-    y: crossAxis * crossAxisMulti
-  };
-}
-
-/**
- * Modifies the placement by translating the floating element along the
- * specified axes.
- * A number (shorthand for `mainAxis` or distance), or an axes configuration
- * object may be passed.
- * @see https://floating-ui.com/docs/offset
- */
-const offset$1 = function (options) {
-  if (options === void 0) {
-    options = 0;
-  }
-  return {
-    name: 'offset',
-    options,
-    async fn(state) {
-      var _middlewareData$offse, _middlewareData$arrow;
-      const {
-        x,
-        y,
-        placement,
-        middlewareData
-      } = state;
-      const diffCoords = await convertValueToCoords(state, options);
-
-      // If the placement is the same and the arrow caused an alignment offset
-      // then we don't need to change the positioning coordinates.
-      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
-        return {};
-      }
-      return {
-        x: x + diffCoords.x,
-        y: y + diffCoords.y,
-        data: {
-          ...diffCoords,
-          placement
-        }
-      };
-    }
-  };
-};
-
-/**
- * Optimizes the visibility of the floating element by shifting it in order to
- * keep it in view when it will overflow the clipping boundary.
- * @see https://floating-ui.com/docs/shift
- */
-const shift$1 = function (options) {
-  if (options === void 0) {
-    options = {};
-  }
-  return {
-    name: 'shift',
-    options,
-    async fn(state) {
-      const {
-        x,
-        y,
-        placement,
-        platform
-      } = state;
-      const {
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = false,
-        limiter = {
-          fn: _ref => {
-            let {
-              x,
-              y
-            } = _ref;
-            return {
-              x,
-              y
-            };
-          }
-        },
-        ...detectOverflowOptions
-      } = evaluate(options, state);
-      const coords = {
-        x,
-        y
-      };
-      const overflow = await platform.detectOverflow(state, detectOverflowOptions);
-      const crossAxis = getSideAxis(getSide(placement));
-      const mainAxis = getOppositeAxis(crossAxis);
-      let mainAxisCoord = coords[mainAxis];
-      let crossAxisCoord = coords[crossAxis];
-      if (checkMainAxis) {
-        const minSide = mainAxis === 'y' ? 'top' : 'left';
-        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
-        const min = mainAxisCoord + overflow[minSide];
-        const max = mainAxisCoord - overflow[maxSide];
-        mainAxisCoord = clamp(min, mainAxisCoord, max);
-      }
-      if (checkCrossAxis) {
-        const minSide = crossAxis === 'y' ? 'top' : 'left';
-        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
-        const min = crossAxisCoord + overflow[minSide];
-        const max = crossAxisCoord - overflow[maxSide];
-        crossAxisCoord = clamp(min, crossAxisCoord, max);
-      }
-      const limitedCoords = limiter.fn({
-        ...state,
-        [mainAxis]: mainAxisCoord,
-        [crossAxis]: crossAxisCoord
-      });
-      return {
-        ...limitedCoords,
-        data: {
-          x: limitedCoords.x - x,
-          y: limitedCoords.y - y,
-          enabled: {
-            [mainAxis]: checkMainAxis,
-            [crossAxis]: checkCrossAxis
-          }
-        }
-      };
-    }
-  };
-};
-
-function hasWindow() {
-  return typeof window !== 'undefined';
-}
-function getNodeName(node) {
-  if (isNode(node)) {
-    return (node.nodeName || '').toLowerCase();
-  }
-  // Mocked nodes in testing environments may not be instances of Node. By
-  // returning `#document` an infinite loop won't occur.
-  // https://github.com/floating-ui/floating-ui/issues/2317
-  return '#document';
-}
-function getWindow(node) {
-  var _node$ownerDocument;
-  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
-}
-function getDocumentElement(node) {
-  var _ref;
-  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
-}
-function isNode(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Node || value instanceof getWindow(value).Node;
-}
-function isElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Element || value instanceof getWindow(value).Element;
-}
-function isHTMLElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
-}
-function isShadowRoot(value) {
-  if (!hasWindow() || typeof ShadowRoot === 'undefined') {
-    return false;
-  }
-  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
-}
-function isOverflowElement(element) {
-  const {
-    overflow,
-    overflowX,
-    overflowY,
-    display
-  } = getComputedStyle$1(element);
-  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== 'inline' && display !== 'contents';
-}
-function isTableElement(element) {
-  return /^(table|td|th)$/.test(getNodeName(element));
-}
-function isTopLayer(element) {
-  try {
-    if (element.matches(':popover-open')) {
-      return true;
-    }
-  } catch (_e) {
-    // no-op
-  }
-  try {
-    return element.matches(':modal');
-  } catch (_e) {
-    return false;
-  }
-}
-const willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
-const containRe = /paint|layout|strict|content/;
-const isNotNone = value => !!value && value !== 'none';
-let isWebKitValue;
-function isContainingBlock(elementOrCss) {
-  const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
-
-  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-  // https://drafts.csswg.org/css-transforms-2/#individual-transforms
-  return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || '') || containRe.test(css.contain || '');
-}
-function getContainingBlock(element) {
-  let currentNode = getParentNode(element);
-  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
-    if (isContainingBlock(currentNode)) {
-      return currentNode;
-    } else if (isTopLayer(currentNode)) {
-      return null;
-    }
-    currentNode = getParentNode(currentNode);
-  }
-  return null;
-}
-function isWebKit() {
-  if (isWebKitValue == null) {
-    isWebKitValue = typeof CSS !== 'undefined' && CSS.supports && CSS.supports('-webkit-backdrop-filter', 'none');
-  }
-  return isWebKitValue;
-}
-function isLastTraversableNode(node) {
-  return /^(html|body|#document)$/.test(getNodeName(node));
-}
-function getComputedStyle$1(element) {
-  return getWindow(element).getComputedStyle(element);
-}
-function getNodeScroll(element) {
-  if (isElement(element)) {
-    return {
-      scrollLeft: element.scrollLeft,
-      scrollTop: element.scrollTop
-    };
-  }
-  return {
-    scrollLeft: element.scrollX,
-    scrollTop: element.scrollY
-  };
-}
-function getParentNode(node) {
-  if (getNodeName(node) === 'html') {
-    return node;
-  }
-  const result =
-  // Step into the shadow DOM of the parent of a slotted node.
-  node.assignedSlot ||
-  // DOM Element detected.
-  node.parentNode ||
-  // ShadowRoot detected.
-  isShadowRoot(node) && node.host ||
-  // Fallback.
-  getDocumentElement(node);
-  return isShadowRoot(result) ? result.host : result;
-}
-function getNearestOverflowAncestor(node) {
-  const parentNode = getParentNode(node);
-  if (isLastTraversableNode(parentNode)) {
-    return node.ownerDocument ? node.ownerDocument.body : node.body;
-  }
-  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
-    return parentNode;
-  }
-  return getNearestOverflowAncestor(parentNode);
-}
-function getOverflowAncestors(node, list, traverseIframes) {
-  var _node$ownerDocument2;
-  if (list === void 0) {
-    list = [];
-  }
-  if (traverseIframes === void 0) {
-    traverseIframes = true;
-  }
-  const scrollableAncestor = getNearestOverflowAncestor(node);
-  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
-  const win = getWindow(scrollableAncestor);
-  if (isBody) {
-    const frameElement = getFrameElement(win);
-    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
-  } else {
-    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
-  }
-}
-function getFrameElement(win) {
-  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
-}
-
-function getCssDimensions(element) {
-  const css = getComputedStyle$1(element);
-  // In testing environments, the `width` and `height` properties are empty
-  // strings for SVG elements, returning NaN. Fallback to `0` in this case.
-  let width = parseFloat(css.width) || 0;
-  let height = parseFloat(css.height) || 0;
-  const hasOffset = isHTMLElement(element);
-  const offsetWidth = hasOffset ? element.offsetWidth : width;
-  const offsetHeight = hasOffset ? element.offsetHeight : height;
-  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
-  if (shouldFallback) {
-    width = offsetWidth;
-    height = offsetHeight;
-  }
-  return {
-    width,
-    height,
-    $: shouldFallback
-  };
-}
-
-function unwrapElement(element) {
-  return !isElement(element) ? element.contextElement : element;
-}
-
-function getScale(element) {
-  const domElement = unwrapElement(element);
-  if (!isHTMLElement(domElement)) {
-    return createCoords(1);
-  }
-  const rect = domElement.getBoundingClientRect();
-  const {
-    width,
-    height,
-    $
-  } = getCssDimensions(domElement);
-  let x = ($ ? round(rect.width) : rect.width) / width;
-  let y = ($ ? round(rect.height) : rect.height) / height;
-
-  // 0, NaN, or Infinity should always fallback to 1.
-
-  if (!x || !Number.isFinite(x)) {
-    x = 1;
-  }
-  if (!y || !Number.isFinite(y)) {
-    y = 1;
-  }
-  return {
-    x,
-    y
-  };
-}
-
-const noOffsets = /*#__PURE__*/createCoords(0);
-function getVisualOffsets(element) {
-  const win = getWindow(element);
-  if (!isWebKit() || !win.visualViewport) {
-    return noOffsets;
-  }
-  return {
-    x: win.visualViewport.offsetLeft,
-    y: win.visualViewport.offsetTop
-  };
-}
-function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
-  if (isFixed === void 0) {
-    isFixed = false;
-  }
-  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
-    return false;
-  }
-  return isFixed;
-}
-
-function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
-  if (includeScale === void 0) {
-    includeScale = false;
-  }
-  if (isFixedStrategy === void 0) {
-    isFixedStrategy = false;
-  }
-  const clientRect = element.getBoundingClientRect();
-  const domElement = unwrapElement(element);
-  let scale = createCoords(1);
-  if (includeScale) {
-    if (offsetParent) {
-      if (isElement(offsetParent)) {
-        scale = getScale(offsetParent);
-      }
-    } else {
-      scale = getScale(element);
-    }
-  }
-  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
-  let x = (clientRect.left + visualOffsets.x) / scale.x;
-  let y = (clientRect.top + visualOffsets.y) / scale.y;
-  let width = clientRect.width / scale.x;
-  let height = clientRect.height / scale.y;
-  if (domElement) {
-    const win = getWindow(domElement);
-    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
-    let currentWin = win;
-    let currentIFrame = getFrameElement(currentWin);
-    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
-      const iframeScale = getScale(currentIFrame);
-      const iframeRect = currentIFrame.getBoundingClientRect();
-      const css = getComputedStyle$1(currentIFrame);
-      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
-      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
-      x *= iframeScale.x;
-      y *= iframeScale.y;
-      width *= iframeScale.x;
-      height *= iframeScale.y;
-      x += left;
-      y += top;
-      currentWin = getWindow(currentIFrame);
-      currentIFrame = getFrameElement(currentWin);
-    }
-  }
-  return rectToClientRect({
-    width,
-    height,
-    x,
-    y
-  });
-}
-
-// If <html> has a CSS width greater than the viewport, then this will be
-// incorrect for RTL.
-function getWindowScrollBarX(element, rect) {
-  const leftScroll = getNodeScroll(element).scrollLeft;
-  if (!rect) {
-    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
-  }
-  return rect.left + leftScroll;
-}
-
-function getHTMLOffset(documentElement, scroll) {
-  const htmlRect = documentElement.getBoundingClientRect();
-  const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
-  const y = htmlRect.top + scroll.scrollTop;
-  return {
-    x,
-    y
-  };
-}
-
-function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
-  let {
-    elements,
-    rect,
-    offsetParent,
-    strategy
-  } = _ref;
-  const isFixed = strategy === 'fixed';
-  const documentElement = getDocumentElement(offsetParent);
-  const topLayer = elements ? isTopLayer(elements.floating) : false;
-  if (offsetParent === documentElement || topLayer && isFixed) {
-    return rect;
-  }
-  let scroll = {
-    scrollLeft: 0,
-    scrollTop: 0
-  };
-  let scale = createCoords(1);
-  const offsets = createCoords(0);
-  const isOffsetParentAnElement = isHTMLElement(offsetParent);
-  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
-    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
-      scroll = getNodeScroll(offsetParent);
-    }
-    if (isOffsetParentAnElement) {
-      const offsetRect = getBoundingClientRect(offsetParent);
-      scale = getScale(offsetParent);
-      offsets.x = offsetRect.x + offsetParent.clientLeft;
-      offsets.y = offsetRect.y + offsetParent.clientTop;
-    }
-  }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
-  return {
-    width: rect.width * scale.x,
-    height: rect.height * scale.y,
-    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
-    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
-  };
-}
-
-function getClientRects(element) {
-  return Array.from(element.getClientRects());
-}
-
-// Gets the entire size of the scrollable document area, even extending outside
-// of the `<html>` and `<body>` rect bounds if horizontally scrollable.
-function getDocumentRect(element) {
-  const html = getDocumentElement(element);
-  const scroll = getNodeScroll(element);
-  const body = element.ownerDocument.body;
-  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
-  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
-  let x = -scroll.scrollLeft + getWindowScrollBarX(element);
-  const y = -scroll.scrollTop;
-  if (getComputedStyle$1(body).direction === 'rtl') {
-    x += max(html.clientWidth, body.clientWidth) - width;
-  }
-  return {
-    width,
-    height,
-    x,
-    y
-  };
-}
-
-// Safety check: ensure the scrollbar space is reasonable in case this
-// calculation is affected by unusual styles.
-// Most scrollbars leave 15-18px of space.
-const SCROLLBAR_MAX = 25;
-function getViewportRect(element, strategy) {
-  const win = getWindow(element);
-  const html = getDocumentElement(element);
-  const visualViewport = win.visualViewport;
-  let width = html.clientWidth;
-  let height = html.clientHeight;
-  let x = 0;
-  let y = 0;
-  if (visualViewport) {
-    width = visualViewport.width;
-    height = visualViewport.height;
-    const visualViewportBased = isWebKit();
-    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
-      x = visualViewport.offsetLeft;
-      y = visualViewport.offsetTop;
-    }
-  }
-  const windowScrollbarX = getWindowScrollBarX(html);
-  // <html> `overflow: hidden` + `scrollbar-gutter: stable` reduces the
-  // visual width of the <html> but this is not considered in the size
-  // of `html.clientWidth`.
-  if (windowScrollbarX <= 0) {
-    const doc = html.ownerDocument;
-    const body = doc.body;
-    const bodyStyles = getComputedStyle(body);
-    const bodyMarginInline = doc.compatMode === 'CSS1Compat' ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
-    const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
-    if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) {
-      width -= clippingStableScrollbarWidth;
-    }
-  } else if (windowScrollbarX <= SCROLLBAR_MAX) {
-    // If the <body> scrollbar is on the left, the width needs to be extended
-    // by the scrollbar amount so there isn't extra space on the right.
-    width += windowScrollbarX;
-  }
-  return {
-    width,
-    height,
-    x,
-    y
-  };
-}
-
-// Returns the inner client rect, subtracting scrollbars if present.
-function getInnerBoundingClientRect(element, strategy) {
-  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
-  const top = clientRect.top + element.clientTop;
-  const left = clientRect.left + element.clientLeft;
-  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
-  const width = element.clientWidth * scale.x;
-  const height = element.clientHeight * scale.y;
-  const x = left * scale.x;
-  const y = top * scale.y;
-  return {
-    width,
-    height,
-    x,
-    y
-  };
-}
-function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
-  let rect;
-  if (clippingAncestor === 'viewport') {
-    rect = getViewportRect(element, strategy);
-  } else if (clippingAncestor === 'document') {
-    rect = getDocumentRect(getDocumentElement(element));
-  } else if (isElement(clippingAncestor)) {
-    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
-  } else {
-    const visualOffsets = getVisualOffsets(element);
-    rect = {
-      x: clippingAncestor.x - visualOffsets.x,
-      y: clippingAncestor.y - visualOffsets.y,
-      width: clippingAncestor.width,
-      height: clippingAncestor.height
-    };
-  }
-  return rectToClientRect(rect);
-}
-function hasFixedPositionAncestor(element, stopNode) {
-  const parentNode = getParentNode(element);
-  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
-    return false;
-  }
-  return getComputedStyle$1(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
-}
-
-// A "clipping ancestor" is an `overflow` element with the characteristic of
-// clipping (or hiding) child elements. This returns all clipping ancestors
-// of the given element up the tree.
-function getClippingElementAncestors(element, cache) {
-  const cachedResult = cache.get(element);
-  if (cachedResult) {
-    return cachedResult;
-  }
-  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
-  let currentContainingBlockComputedStyle = null;
-  const elementIsFixed = getComputedStyle$1(element).position === 'fixed';
-  let currentNode = elementIsFixed ? getParentNode(element) : element;
-
-  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
-    const computedStyle = getComputedStyle$1(currentNode);
-    const currentNodeIsContaining = isContainingBlock(currentNode);
-    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
-      currentContainingBlockComputedStyle = null;
-    }
-    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === 'absolute' || currentContainingBlockComputedStyle.position === 'fixed') || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
-    if (shouldDropCurrentNode) {
-      // Drop non-containing blocks.
-      result = result.filter(ancestor => ancestor !== currentNode);
-    } else {
-      // Record last containing block for next iteration.
-      currentContainingBlockComputedStyle = computedStyle;
-    }
-    currentNode = getParentNode(currentNode);
-  }
-  cache.set(element, result);
-  return result;
-}
-
-// Gets the maximum area that the element is visible in due to any number of
-// clipping ancestors.
-function getClippingRect(_ref) {
-  let {
-    element,
-    boundary,
-    rootBoundary,
-    strategy
-  } = _ref;
-  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
-  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
-  const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
-  let top = firstRect.top;
-  let right = firstRect.right;
-  let bottom = firstRect.bottom;
-  let left = firstRect.left;
-  for (let i = 1; i < clippingAncestors.length; i++) {
-    const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
-    top = max(rect.top, top);
-    right = min(rect.right, right);
-    bottom = min(rect.bottom, bottom);
-    left = max(rect.left, left);
-  }
-  return {
-    width: right - left,
-    height: bottom - top,
-    x: left,
-    y: top
-  };
-}
-
-function getDimensions(element) {
-  const {
-    width,
-    height
-  } = getCssDimensions(element);
-  return {
-    width,
-    height
-  };
-}
-
-function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
-  const isOffsetParentAnElement = isHTMLElement(offsetParent);
-  const documentElement = getDocumentElement(offsetParent);
-  const isFixed = strategy === 'fixed';
-  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
-  let scroll = {
-    scrollLeft: 0,
-    scrollTop: 0
-  };
-  const offsets = createCoords(0);
-
-  // If the <body> scrollbar appears on the left (e.g. RTL systems). Use
-  // Firefox with layout.scrollbar.side = 3 in about:config to test this.
-  function setLeftRTLScrollbarOffset() {
-    offsets.x = getWindowScrollBarX(documentElement);
-  }
-  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
-    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
-      scroll = getNodeScroll(offsetParent);
-    }
-    if (isOffsetParentAnElement) {
-      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
-      offsets.x = offsetRect.x + offsetParent.clientLeft;
-      offsets.y = offsetRect.y + offsetParent.clientTop;
-    } else if (documentElement) {
-      setLeftRTLScrollbarOffset();
-    }
-  }
-  if (isFixed && !isOffsetParentAnElement && documentElement) {
-    setLeftRTLScrollbarOffset();
-  }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
-  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
-  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
-  return {
-    x,
-    y,
-    width: rect.width,
-    height: rect.height
-  };
-}
-
-function isStaticPositioned(element) {
-  return getComputedStyle$1(element).position === 'static';
-}
-
-function getTrueOffsetParent(element, polyfill) {
-  if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {
-    return null;
-  }
-  if (polyfill) {
-    return polyfill(element);
-  }
-  let rawOffsetParent = element.offsetParent;
-
-  // Firefox returns the <html> element as the offsetParent if it's non-static,
-  // while Chrome and Safari return the <body> element. The <body> element must
-  // be used to perform the correct calculations even if the <html> element is
-  // non-static.
-  if (getDocumentElement(element) === rawOffsetParent) {
-    rawOffsetParent = rawOffsetParent.ownerDocument.body;
-  }
-  return rawOffsetParent;
-}
-
-// Gets the closest ancestor positioned element. Handles some edge cases,
-// such as table ancestors and cross browser bugs.
-function getOffsetParent(element, polyfill) {
-  const win = getWindow(element);
-  if (isTopLayer(element)) {
-    return win;
-  }
-  if (!isHTMLElement(element)) {
-    let svgOffsetParent = getParentNode(element);
-    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
-      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
-        return svgOffsetParent;
-      }
-      svgOffsetParent = getParentNode(svgOffsetParent);
-    }
-    return win;
-  }
-  let offsetParent = getTrueOffsetParent(element, polyfill);
-  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
-    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
-  }
-  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
-    return win;
-  }
-  return offsetParent || getContainingBlock(element) || win;
-}
-
-const getElementRects = async function (data) {
-  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
-  const getDimensionsFn = this.getDimensions;
-  const floatingDimensions = await getDimensionsFn(data.floating);
-  return {
-    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
-    floating: {
-      x: 0,
-      y: 0,
-      width: floatingDimensions.width,
-      height: floatingDimensions.height
-    }
-  };
-};
-
-function isRTL(element) {
-  return getComputedStyle$1(element).direction === 'rtl';
-}
-
-const platform = {
-  convertOffsetParentRelativeRectToViewportRelativeRect,
-  getDocumentElement,
-  getClippingRect,
-  getOffsetParent,
-  getElementRects,
-  getClientRects,
-  getDimensions,
-  getScale,
-  isElement,
-  isRTL
-};
-
-function rectsAreEqual(a, b) {
-  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
-}
-
-// https://samthor.au/2021/observing-dom/
-function observeMove(element, onMove) {
-  let io = null;
-  let timeoutId;
-  const root = getDocumentElement(element);
-  function cleanup() {
-    var _io;
-    clearTimeout(timeoutId);
-    (_io = io) == null || _io.disconnect();
-    io = null;
-  }
-  function refresh(skip, threshold) {
-    if (skip === void 0) {
-      skip = false;
-    }
-    if (threshold === void 0) {
-      threshold = 1;
-    }
-    cleanup();
-    const elementRectForRootMargin = element.getBoundingClientRect();
-    const {
-      left,
-      top,
-      width,
-      height
-    } = elementRectForRootMargin;
-    if (!skip) {
-      onMove();
-    }
-    if (!width || !height) {
-      return;
-    }
-    const insetTop = floor(top);
-    const insetRight = floor(root.clientWidth - (left + width));
-    const insetBottom = floor(root.clientHeight - (top + height));
-    const insetLeft = floor(left);
-    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
-    const options = {
-      rootMargin,
-      threshold: max(0, min(1, threshold)) || 1
-    };
-    let isFirstUpdate = true;
-    function handleObserve(entries) {
-      const ratio = entries[0].intersectionRatio;
-      if (ratio !== threshold) {
-        if (!isFirstUpdate) {
-          return refresh();
-        }
-        if (!ratio) {
-          // If the reference is clipped, the ratio is 0. Throttle the refresh
-          // to prevent an infinite loop of updates.
-          timeoutId = setTimeout(() => {
-            refresh(false, 1e-7);
-          }, 1000);
-        } else {
-          refresh(false, ratio);
-        }
-      }
-      if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
-        // It's possible that even though the ratio is reported as 1, the
-        // element is not actually fully within the IntersectionObserver's root
-        // area anymore. This can happen under performance constraints. This may
-        // be a bug in the browser's IntersectionObserver implementation. To
-        // work around this, we compare the element's bounding rect now with
-        // what it was at the time we created the IntersectionObserver. If they
-        // are not equal then the element moved, so we refresh.
-        refresh();
-      }
-      isFirstUpdate = false;
-    }
-
-    // Older browsers don't support a `document` as the root and will throw an
-    // error.
-    try {
-      io = new IntersectionObserver(handleObserve, {
-        ...options,
-        // Handle <iframe>s
-        root: root.ownerDocument
-      });
-    } catch (_e) {
-      io = new IntersectionObserver(handleObserve, options);
-    }
-    io.observe(element);
-  }
-  refresh(true);
-  return cleanup;
-}
-
-/**
- * Automatically updates the position of the floating element when necessary.
- * Should only be called when the floating element is mounted on the DOM or
- * visible on the screen.
- * @returns cleanup function that should be invoked when the floating element is
- * removed from the DOM or hidden from the screen.
- * @see https://floating-ui.com/docs/autoUpdate
- */
-function autoUpdate(reference, floating, update, options) {
-  if (options === void 0) {
-    options = {};
-  }
-  const {
-    ancestorScroll = true,
-    ancestorResize = true,
-    elementResize = typeof ResizeObserver === 'function',
-    layoutShift = typeof IntersectionObserver === 'function',
-    animationFrame = false
-  } = options;
-  const referenceEl = unwrapElement(reference);
-  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...(floating ? getOverflowAncestors(floating) : [])] : [];
-  ancestors.forEach(ancestor => {
-    ancestorScroll && ancestor.addEventListener('scroll', update, {
-      passive: true
-    });
-    ancestorResize && ancestor.addEventListener('resize', update);
-  });
-  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
-  let reobserveFrame = -1;
-  let resizeObserver = null;
-  if (elementResize) {
-    resizeObserver = new ResizeObserver(_ref => {
-      let [firstEntry] = _ref;
-      if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
-        // Prevent update loops when using the `size` middleware.
-        // https://github.com/floating-ui/floating-ui/issues/1740
-        resizeObserver.unobserve(floating);
-        cancelAnimationFrame(reobserveFrame);
-        reobserveFrame = requestAnimationFrame(() => {
-          var _resizeObserver;
-          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
-        });
-      }
-      update();
-    });
-    if (referenceEl && !animationFrame) {
-      resizeObserver.observe(referenceEl);
-    }
-    if (floating) {
-      resizeObserver.observe(floating);
-    }
-  }
-  let frameId;
-  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
-  if (animationFrame) {
-    frameLoop();
-  }
-  function frameLoop() {
-    const nextRefRect = getBoundingClientRect(reference);
-    if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
-      update();
-    }
-    prevRefRect = nextRefRect;
-    frameId = requestAnimationFrame(frameLoop);
-  }
-  update();
-  return () => {
-    var _resizeObserver2;
-    ancestors.forEach(ancestor => {
-      ancestorScroll && ancestor.removeEventListener('scroll', update);
-      ancestorResize && ancestor.removeEventListener('resize', update);
-    });
-    cleanupIo == null || cleanupIo();
-    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
-    resizeObserver = null;
-    if (animationFrame) {
-      cancelAnimationFrame(frameId);
-    }
-  };
-}
-
-/**
- * Modifies the placement by translating the floating element along the
- * specified axes.
- * A number (shorthand for `mainAxis` or distance), or an axes configuration
- * object may be passed.
- * @see https://floating-ui.com/docs/offset
- */
-const offset = offset$1;
-
-/**
- * Optimizes the visibility of the floating element by shifting it in order to
- * keep it in view when it will overflow the clipping boundary.
- * @see https://floating-ui.com/docs/shift
- */
-const shift = shift$1;
-
-/**
- * Optimizes the visibility of the floating element by flipping the `placement`
- * in order to keep it in view when the preferred placement(s) will overflow the
- * clipping boundary. Alternative to `autoPlacement`.
- * @see https://floating-ui.com/docs/flip
- */
-const flip = flip$1;
-
-/**
- * Computes the `x` and `y` coordinates that will place the floating element
- * next to a given reference element.
- */
-const computePosition = (reference, floating, options) => {
-  // This caches the expensive `getClippingElementAncestors` function so that
-  // multiple lifecycle resets re-use the same result. It only lives for a
-  // single call. If other functions become expensive, we can add them as well.
-  const cache = new Map();
-  const mergedOptions = {
-    platform,
-    ...options
-  };
-  const platformWithCache = {
-    ...mergedOptions.platform,
-    _c: cache
-  };
-  return computePosition$1(reference, floating, {
-    ...mergedOptions,
-    platform: platformWithCache
-  });
-};
-
-class PopoverController {
-    constructor(host, options = { placement: 'bottom', offset: 6 }) {
-        this.host = host;
-        this.options = options;
-        this.host.addController(this);
-    }
-    // Set up the floating logic
-    async updatePosition(reference, floating, options) {
-        if (!reference)
-            return;
-        this.cleanup?.();
-        const placement = options?.placement ?? this.options.placement;
-        const spacing = options?.offset ?? this.options.offset;
-        this.cleanup = autoUpdate(reference, floating, async () => {
-            const { x, y } = await computePosition(reference, floating, {
-                placement,
-                middleware: [offset(spacing), flip(), shift({ padding: 4 })],
-            });
-            Object.assign(floating.style, {
-                left: `${x}px`,
-                top: `${y}px`,
-                position: 'absolute',
-            });
-        });
-    }
-    hostDisconnected() {
-        this.cleanup?.();
-    }
-}
-
 /**
  * @label Tooltip
  * @tag wc-tooltip
@@ -8066,84 +6252,30 @@ class Tooltip extends i$1 {
         this.variant = 'plain';
         this.preview = false;
         this._target = null;
-        this._popover = new PopoverController(this, {
-            placement: 'top',
-            offset: 8,
-        });
-        // Define listeners as arrow functions to maintain 'this' context
-        this._onMouseEnter = () => {
-            if (this.preview || !this.hasTrigger('hover'))
-                return;
-            window.clearTimeout(this._hideTimeout); // Cancel any pending close
-            this.show();
-        };
-        this._onMouseLeave = () => {
-            if (this.preview || !this.hasTrigger('hover'))
-                return;
-            // Small delay allows the mouse to move from target -> tooltip
-            // without the tooltip vanishing instantly.
-            this._hideTimeout = window.setTimeout(() => {
-                // Only hide if the mouse isn't currently hovering the target OR the tooltip
-                const isHoveringTarget = this._target?.matches(':hover');
-                const isHoveringTooltip = this.floatingEl?.matches(':hover');
-                if (!isHoveringTarget && !isHoveringTooltip) {
-                    this.hide();
-                }
-            }, 100); // 100ms is usually enough for a smooth transition
-        };
-        this._onFocusIn = () => this.preview && this.hasTrigger('focus') && this.show();
-        this._onFocusOut = (e) => {
-            if (this.preview || !this.hasTrigger('focus'))
-                return;
-            if (this._target && !this._target.contains(e.relatedTarget)) {
-                this.hide();
-            }
-        };
-        this._onClick = (e) => {
-            if (this.preview || !this.hasTrigger('click'))
-                return;
-            e.stopPropagation();
-            this.toggle();
-        };
-        this._handleGlobalOpen = (e) => {
-            if (e.detail.invoker !== this)
-                this.hide();
-        };
-        this._handleDocumentClick = (e) => {
-            const path = e.composedPath();
-            if (this._target && !path.includes(this._target)) {
-                this.hide();
-            }
-        };
-    }
-    hasTrigger(type) {
-        return this.trigger.split(' ').includes(type);
-    }
-    show() {
-        if (this.open)
-            return;
-        window.dispatchEvent(new CustomEvent(Tooltip.CLOSE_OTHERS_EVENT, {
-            detail: { invoker: this },
-        }));
-        this.open = true;
-    }
-    hide() {
-        if (!this.open)
-            return;
-        this.open = false;
-    }
-    toggle() {
-        // eslint-disable-next-line no-unused-expressions
-        this.open ? this.hide() : this.show();
+        this._floating = null;
+    }
+    resolveTrigger() {
+        if (this.preview)
+            return 'manual';
+        const triggerTokens = this.trigger.split(' ');
+        const hasHover = triggerTokens.includes('hover');
+        const hasFocus = triggerTokens.includes('focus');
+        const hasClick = triggerTokens.includes('click');
+        if (hasClick)
+            return 'click';
+        if (hasHover && hasFocus)
+            return 'hover-focus';
+        if (hasFocus)
+            return 'focus';
+        if (hasHover)
+            return 'hover';
+        return 'manual';
     }
     detachListeners() {
-        if (!this._target)
-            return;
-        this._target.removeEventListener('mouseenter', this._onMouseEnter);
-        this._target.removeEventListener('mouseleave', this._onMouseLeave);
-        this._target.removeEventListener('focusin', this._onFocusIn);
-        this._target.removeEventListener('focusout', this._onFocusOut);
-        this._target.removeEventListener('click', this._onClick);
+        if (this._floating) {
+            this._floating.close();
+            this._floating = null;
+        }
         this._target = null;
     }
     set forElement(value) {
@@ -8165,7 +6297,7 @@ class Tooltip extends i$1 {
         return this.parentElement;
     }
     attachListeners() {
-        this.detachListeners(); // Cleanup old target if it exists
+        this.detachListeners();
         // Resolve target: ID-based lookup or fallback to parent
         const root = this.getRootNode();
         this._target = this.for
@@ -8173,22 +6305,26 @@ class Tooltip extends i$1 {
             : this.parentElement;
         if (!this._target)
             return;
-        this._target.addEventListener('mouseenter', this._onMouseEnter);
-        this._target.addEventListener('mouseleave', this._onMouseLeave);
-        this._target.addEventListener('focusin', this._onFocusIn);
-        this._target.addEventListener('focusout', this._onFocusOut);
-        this._target.addEventListener('click', this._onClick);
+        this._floating = new FloatingController(this, {
+            placement: 'top',
+            strategy: 'fixed',
+            offset: 0,
+            trigger: this.resolveTrigger(),
+            closeOnClickOutside: true,
+            onOpenChange: (isOpen) => {
+                if (this.open === isOpen)
+                    return;
+                this.open = isOpen;
+            },
+        });
+        this._floating.setElements(this._target, this);
     }
     connectedCallback() {
         super.connectedCallback();
         this.attachListeners();
-        window.addEventListener(Tooltip.CLOSE_OTHERS_EVENT, this._handleGlobalOpen);
-        window.addEventListener('click', this._handleDocumentClick);
     }
     disconnectedCallback() {
         this.detachListeners();
-        window.removeEventListener(Tooltip.CLOSE_OTHERS_EVENT, this._handleGlobalOpen);
-        window.removeEventListener('click', this._handleDocumentClick);
         super.disconnectedCallback();
     }
     updated(changedProps) {
@@ -8196,21 +6332,28 @@ class Tooltip extends i$1 {
         if (changedProps.has('for')) {
             this.attachListeners();
         }
-        if (changedProps.has('open') && this.open && this._target) {
-            this._popover.updatePosition(this._target, this.floatingEl);
+        if (changedProps.has('trigger') || changedProps.has('preview')) {
+            this.attachListeners();
+        }
+        if (this._floating && this._target) {
+            this._floating.setElements(this._target, this);
+            if (changedProps.has('open') && this.open && !this._floating.isOpen) {
+                this._floating.open();
+            }
+            if (changedProps.has('open') && !this.open && this._floating.isOpen) {
+                this._floating.close();
+            }
         }
     }
     render() {
         return b ` <div
-      class=${e$3({
+      class=${e$1({
             tooltip: true,
             open: this.open,
             [`variant-${this.variant}`]: true,
         })}
       id="tooltip"
       role="tooltip"
-      @mouseenter=${this._onMouseEnter}
-      @mouseleave=${this._onMouseLeave}
       aria-hidden=${!this.open}
       aria-labelledby="tooltip-labelledby"
     >
@@ -8245,7 +6388,6 @@ class Tooltip extends i$1 {
     }
 }
 Tooltip.styles = [css_248z$m];
-Tooltip.CLOSE_OTHERS_EVENT = 'tooltip--open';
 __decorate([
     n()
 ], Tooltip.prototype, "content", void 0);
@@ -8264,9 +6406,6 @@ __decorate([
 __decorate([
     n({ type: Boolean, reflect: true })
 ], Tooltip.prototype, "preview", void 0);
-__decorate([
-    e$4('#tooltip')
-], Tooltip.prototype, "floatingEl", void 0);
 
 var css_248z$l = i`* {
   box-sizing: border-box;
@@ -8398,7 +6537,7 @@ class BreadcrumbItem extends i$1 {
     render() {
         return b `
       <li
-        class=${e$3({ 'breadcrumb-item': true, active: this.active })}
+        class=${e$1({ 'breadcrumb-item': true, active: this.active })}
         itemprop="itemListElement"
         itemscope
         itemtype="https://schema.org/ListItem"
@@ -8413,8 +6552,8 @@ class BreadcrumbItem extends i$1 {
               <a
                 class="breadcrumb-link"
                 itemprop="item"
-                href=${o$3(this.href)}
-                target=${o$3(this.target)}
+                href=${o$2(this.href)}
+                target=${o$2(this.target)}
                 ${this.target === '_blank'
                 ? b `rel="noopener noreferrer"`
                 : A}
@@ -8511,8 +6650,8 @@ var css_248z$j = i`* {
   min-width: 112px;
   padding-block: var(--spacing-050);
   transform-origin: top center;
-  --_menu-enter-duration: var(--duration-medium1, 250ms);
-  --_menu-exit-duration: var(--duration-short4, 200ms);
+  --_menu-enter-duration: var(--duration-medium1);
+  --_menu-exit-duration: var(--duration-medium2);
   --_menu-enter-easing: cubic-bezier(0.05, 0.7, 0.1, 1);
   --_menu-exit-easing: cubic-bezier(0.3, 0, 0.8, 0.15);
   transition-property: opacity, transform, visibility;
@@ -8694,6 +6833,9 @@ var css_248z$i = i`* {
 .menu-item:hover:not(:where(.disabled, .selected)) {
   --_container-state-opacity: 0.08;
 }
+.menu-item.pressed:not(:where(.disabled)) {
+  --_container-state-opacity: 0.12;
+}
 .menu-item.selected {
   --_container-color: var(--menu-item-container-selected-color);
   --_label-text-color: var(--menu-item-label-selected-color);
@@ -8739,20 +6881,67 @@ var css_248z$h = i`:host-context([variant=standard]) {
  * <wc-menu-item>Menu Item</wc-menu-item>
  * ```
  */
-class MenuItem extends i$1 {
+class MenuItem extends BaseButtonMixin(BaseHyperlinkMixin(i$1)) {
     constructor() {
         super(...arguments);
-        this.disabled = false;
         this.value = '';
         this.selected = false;
         this.keepOpen = false;
         this.hasSubmenu = false;
         this.submenuOpen = false;
-        /**
-         * Sets or retrieves the window or frame at which to target content.
-         */
-        this.target = '_self';
         this.variant = 'standard';
+        /**
+           * States
+           */
+        this.isPressed = false;
+        this.__dispatchClickWithThrottle = event => {
+            this.__dispatchClick(event);
+        };
+        this.__dispatchClick = (event) => {
+            // If the button is soft-disabled or a disabled link, we need to explicitly
+            // prevent the click from propagating to other event listeners as well as
+            // prevent the default action.
+            if (this.softDisabled || (this.disabled && this.href)) {
+                event.stopImmediatePropagation();
+                event.preventDefault();
+                return;
+            }
+            if (!isActivationClick(event) || !this.itemElement) {
+                return;
+            }
+            this.focus();
+            dispatchActivationClick(this.itemElement);
+        };
+        this.__handleKeyDown = (event) => {
+            this.__handlePress(event);
+            if (this.disabled || this.softDisabled || !this.itemElement) {
+                return;
+            }
+            if (event.key === ' ') {
+                event.preventDefault();
+                this.itemElement.click();
+                return;
+            }
+            if (event.key === 'Enter' && !this.__isLink()) {
+                event.preventDefault();
+                this.itemElement.click();
+            }
+        };
+        this.__handlePress = (event) => {
+            if (this.disabled || this.softDisabled)
+                return;
+            if (event instanceof KeyboardEvent &&
+                event.type === 'keydown' &&
+                (event.key === 'Enter' || event.key === ' ')) {
+                this.isPressed = true;
+            }
+            else if (event.type === 'mousedown') {
+                this.isPressed = true;
+            }
+            else {
+                this.isPressed = false;
+            }
+        };
     }
     connectedCallback() {
         // eslint-disable-next-line wc/guard-super-call
@@ -8760,73 +6949,19 @@ class MenuItem extends i$1 {
         if (!this.hasAttribute('role')) {
             this.setAttribute('role', 'menuitem');
         }
-        if (!this.hasAttribute('tabindex')) {
-            this.tabIndex = -1;
-        }
-        this.addEventListener('click', this._handleClick);
-        this.addEventListener('keydown', this._handleKeyDown);
+        this.addEventListener('click', this.__dispatchClickWithThrottle);
+        window.addEventListener('mouseup', this.__handlePress);
     }
     disconnectedCallback() {
-        this.removeEventListener('click', this._handleClick);
-        this.removeEventListener('keydown', this._handleKeyDown);
+        window.removeEventListener('mouseup', this.__handlePress);
+        this.removeEventListener('click', this.__dispatchClickWithThrottle);
         super.disconnectedCallback();
     }
-    emitActivate(source, key) {
-        this.dispatchEvent(new CustomEvent('menu-item-activate', {
-            bubbles: true,
-            composed: true,
-            detail: { item: this, source, key },
-        }));
-    }
-    requestClose(source, key) {
-        this.dispatchEvent(new CustomEvent('menu-item-request-close', {
-            bubbles: true,
-            composed: true,
-            detail: {
-                item: this,
-                source,
-                key,
-                reason: source === 'click' ? 'click-selection' : 'keydown',
-            },
-        }));
-    }
-    requestSubmenuKey(key) {
-        this.dispatchEvent(new CustomEvent('menu-item-submenu-keydown', {
-            bubbles: true,
-            composed: true,
-            detail: { item: this, key },
-        }));
-    }
-    _handleKeyDown(e) {
-        if (this.disabled) {
-            e.preventDefault();
-            return;
-        }
-        if (e.key === 'ArrowRight' || e.key === 'ArrowLeft') {
-            this.requestSubmenuKey(e.key);
-            return;
-        }
-        if (e.key === 'Enter' || e.key === ' ') {
-            e.preventDefault();
-            this.emitActivate('keydown', e.key);
-            if (!this.keepOpen) {
-                this.requestClose('keydown', e.key);
-            }
-        }
-    }
-    _handleClick(e) {
-        if (this.disabled) {
-            e.preventDefault();
-            e.stopPropagation();
-            return;
-        }
-        this.emitActivate('click');
-        if (!this.keepOpen) {
-            this.requestClose('click');
-        }
+    focus() {
+        this.itemElement?.focus();
     }
-    __isLink() {
-        return !!this.href;
+    blur() {
+        this.itemElement?.blur();
     }
     render() {
         const isLink = this.__isLink();
@@ -8834,14 +6969,22 @@ class MenuItem extends i$1 {
             'menu-item': true,
             disabled: this.disabled,
             selected: this.selected,
+            pressed: this.isPressed,
         };
         const controls = this.getAttribute('aria-controls');
         if (isLink) {
             return b `<a
         id="item"
-        class=${e$3(cssClasses)}
+        class=${e$1(cssClasses)}
         href=${this.href}
         target=${this.target}
+        tabindex=${this.disabled ? '-1' : '0'}
+
+        @click=${this.__dispatchClickWithThrottle}
+        @mousedown=${this.__handlePress}
+        @keydown=${this.__handleKeyDown}
+        @keyup=${this.__handlePress}
+
         aria-disabled=${String(this.disabled)}
         aria-haspopup=${this.hasSubmenu ? 'menu' : A}
         aria-controls=${this.hasSubmenu && controls ? controls : A}
@@ -8852,7 +6995,14 @@ class MenuItem extends i$1 {
         }
         return b `<div
       id="item"
-      class=${e$3(cssClasses)}
+      class=${e$1(cssClasses)}
+      tabindex=${this.disabled ? '-1' : '0'}
+
+      @click=${this.__dispatchClick}
+      @mousedown=${this.__handlePress}
+      @keydown=${this.__handleKeyDown}
+      @keyup=${this.__handlePress}
+
       aria-disabled=${String(this.disabled)}
       aria-haspopup=${this.hasSubmenu ? 'menu' : A}
       aria-controls=${this.hasSubmenu && controls ? controls : A}
@@ -8867,7 +7017,7 @@ class MenuItem extends i$1 {
       <div class="background"></div>
       <wc-ripple class="ripple"></wc-ripple>
 
-      <div class="menu-item-content">
+      <div class="menu-item-content" data-variant=${this.variant}>
         <slot name="leading-icon"></slot>
         <div class="slot-container">
           <slot></slot>
@@ -8878,9 +7028,6 @@ class MenuItem extends i$1 {
     }
 }
 MenuItem.styles = [css_248z$i, css_248z$h];
-__decorate([
-    n({ type: Boolean, reflect: true })
-], MenuItem.prototype, "disabled", void 0);
 __decorate([
     n({ type: String })
 ], MenuItem.prototype, "value", void 0);
@@ -8896,49 +7043,15 @@ __decorate([
 __decorate([
     n({ type: Boolean, attribute: 'submenu-open' })
 ], MenuItem.prototype, "submenuOpen", void 0);
-__decorate([
-    n({ reflect: true })
-], MenuItem.prototype, "href", void 0);
-__decorate([
-    n()
-], MenuItem.prototype, "target", void 0);
 __decorate([
     n({ type: String, reflect: true })
 ], MenuItem.prototype, "variant", void 0);
-
-async function updateSurfacePosition(options) {
-    const { x, y } = await computePosition(options.reference, options.floating, {
-        strategy: options.strategy,
-        placement: options.placement,
-        middleware: [offset(options.offset), flip(), shift({ padding: 8 })],
-    });
-    Object.assign(options.floating.style, {
-        position: options.strategy,
-        left: `${x}px`,
-        top: `${y}px`,
-    });
-}
-class MenuSurfaceController {
-    constructor(host) {
-        this.host = host;
-        this.host.addController(this);
-    }
-    start(options) {
-        this.stop();
-        const strategy = options.strategy ?? 'fixed';
-        this.cleanup = autoUpdate(options.reference, options.floating, () => {
-            updateSurfacePosition({ ...options, strategy });
-        });
-        updateSurfacePosition({ ...options, strategy });
-    }
-    stop() {
-        this.cleanup?.();
-        this.cleanup = undefined;
-    }
-    hostDisconnected() {
-        this.stop();
-    }
-}
+__decorate([
+    e$2('#item')
+], MenuItem.prototype, "itemElement", void 0);
+__decorate([
+    r()
+], MenuItem.prototype, "isPressed", void 0);
 
 /**
  * @label Menu
@@ -8969,44 +7082,44 @@ class Menu extends i$1 {
         this.offset = 6;
         this.activeIndex = -1;
         this.anchorElement = null;
-        this._surfaceController = new MenuSurfaceController(this);
+        this._floatingController = new FloatingController(this, {
+            trigger: 'manual',
+            closeOnClickOutside: false,
+            strategy: 'fixed',
+            onOpenChange: (isOpen) => {
+                if (isOpen || !this.open) {
+                    return;
+                }
+                this.close({ kind: 'outside-click' });
+            },
+        });
         this._lastFocusedElement = null;
         this._closeReason = { kind: 'programmatic' };
-        this._onItemActivate = (event) => {
-            const customEvent = event;
-            const { item } = customEvent.detail;
-            const ownedItems = this.items;
-            if (!ownedItems.includes(item)) {
-                return;
-            }
-            const enabledItems = this._enabledItems();
-            const nextIndex = enabledItems.indexOf(item);
-            if (nextIndex >= 0) {
-                this.activeIndex = nextIndex;
-                this._syncRovingTabIndex();
-            }
-        };
-        this._onItemRequestClose = (event) => {
-            const customEvent = event;
-            if (!this.items.includes(customEvent.detail.item)) {
+        this._onClick = (event) => {
+            if (!this.open) {
                 return;
             }
-            if (customEvent.defaultPrevented) {
+            const item = this._ownedItemFromEvent(event);
+            if (!item) {
                 return;
             }
-            if (customEvent.detail.reason === 'click-selection') {
-                this.close({ kind: 'click-selection' });
+            this._setActiveItem(item);
+            if (item.keepOpen) {
                 return;
             }
-            this.close({ kind: 'keydown', key: customEvent.detail.key ?? 'Enter' });
+            this.close({ kind: 'click-selection' });
         };
         this._onKeyDown = (event) => {
             if (!this.open) {
                 return;
             }
-            if (!this._ownsKeyboardEvent(event)) {
+            if (!this._isEventFromThisMenu(event)) {
                 return;
             }
+            const eventItem = this._ownedItemFromEvent(event);
+            if (eventItem) {
+                this._setActiveItem(eventItem);
+            }
             switch (event.key) {
                 case 'ArrowDown':
                     event.preventDefault();
@@ -9030,33 +7143,22 @@ class Menu extends i$1 {
                     event.preventDefault();
                     this.close({ kind: 'keydown', key: 'Escape' });
                     break;
+                case 'Tab':
+                    this.close({ kind: 'keydown', key: 'Tab' });
+                    break;
+                case 'Enter':
+                case ' ': {
+                    event.preventDefault();
+                    const activeItem = this._getActiveItem() ?? this._getFirstEnabledItem();
+                    if (!activeItem) {
+                        return;
+                    }
+                    this._setActiveItem(activeItem);
+                    activeItem.click();
+                    break;
+                }
             }
         };
-        this._onWindowClick = (event) => {
-            if (!this.open || this.stayOpenOnOutsideClick) {
-                return;
-            }
-            const path = event.composedPath();
-            const anchorEl = this._resolveAnchorElement();
-            const inMenuTree = path.some(target => target === this || (target instanceof Node && this.contains(target)));
-            if (inMenuTree || (anchorEl && path.includes(anchorEl))) {
-                return;
-            }
-            this.close({ kind: 'outside-click' });
-        };
-        this._onFocusOut = (event) => {
-            if (!this.open || this.stayOpenOnFocusout) {
-                return;
-            }
-            const next = event.relatedTarget;
-            if (!next) {
-                return;
-            }
-            if (next instanceof Node && this._isWithinMenuTree(next)) {
-                return;
-            }
-            this.close({ kind: 'focusout' });
-        };
         this._onSlotChange = () => {
             this._syncRovingTabIndex();
         };
@@ -9066,18 +7168,13 @@ class Menu extends i$1 {
         super.connectedCallback();
         this.setAttribute('role', 'menu');
         this.addEventListener('keydown', this._onKeyDown);
-        this.addEventListener('focusout', this._onFocusOut);
-        this.addEventListener('menu-item-activate', this._onItemActivate);
-        this.addEventListener('menu-item-request-close', this._onItemRequestClose);
-        window.addEventListener('click', this._onWindowClick, { capture: true });
+        this.addEventListener('click', this._onClick);
         this._syncAnchorAria();
     }
     disconnectedCallback() {
         this.removeEventListener('keydown', this._onKeyDown);
-        this.removeEventListener('focusout', this._onFocusOut);
-        this.removeEventListener('menu-item-activate', this._onItemActivate);
-        this.removeEventListener('menu-item-request-close', this._onItemRequestClose);
-        window.removeEventListener('click', this._onWindowClick, { capture: true });
+        this.removeEventListener('click', this._onClick);
+        this._floatingController.close();
         super.disconnectedCallback();
     }
     get items() {
@@ -9144,7 +7241,11 @@ class Menu extends i$1 {
         return this.items.filter(item => !item.disabled);
     }
     _syncRovingTabIndex() {
+        const ownedItems = this.items;
         const enabledItems = this._enabledItems();
+        for (const item of ownedItems) {
+            item.tabIndex = -1;
+        }
         if (!enabledItems.length) {
             this.activeIndex = -1;
             return;
@@ -9152,10 +7253,7 @@ class Menu extends i$1 {
         if (this.activeIndex < 0 || this.activeIndex >= enabledItems.length) {
             this.activeIndex = 0;
         }
-        for (let index = 0; index < enabledItems.length; index += 1) {
-            const currentItem = enabledItems[index];
-            currentItem.tabIndex = index === this.activeIndex ? 0 : -1;
-        }
+        enabledItems[this.activeIndex].tabIndex = 0;
     }
     _setActiveByOffset(offset) {
         const enabledItems = this._enabledItems();
@@ -9191,29 +7289,38 @@ class Menu extends i$1 {
     _getFirstEnabledItem() {
         return this._enabledItems()[0] ?? null;
     }
-    _ownsKeyboardEvent(event) {
+    _isEventFromThisMenu(event) {
         const path = event.composedPath();
-        const ownedItems = this.items;
-        return path.some(target => target instanceof MenuItem && ownedItems.includes(target));
+        const sourceMenu = path.find(target => target instanceof HTMLElement &&
+            target.tagName.toLowerCase() === 'wc-menu');
+        return sourceMenu === this;
     }
-    _isWithinMenuTree(node) {
-        if (!node) {
-            return false;
+    _ownedItemFromEvent(event) {
+        if (!this._isEventFromThisMenu(event)) {
+            return null;
         }
-        let current = node;
-        while (current) {
-            if (current === this || this.contains(current)) {
-                return true;
-            }
-            const root = current.getRootNode();
-            if (root instanceof ShadowRoot) {
-                current = root.host;
-            }
-            else {
-                current = null;
+        const path = event.composedPath();
+        const ownedItems = this.items;
+        for (const target of path) {
+            if (target instanceof HTMLElement) {
+                if (target.tagName.toLowerCase() === 'wc-menu-item') {
+                    const ownedItem = ownedItems.find(item => item === target);
+                    if (ownedItem) {
+                        return ownedItem;
+                    }
+                }
             }
         }
-        return false;
+        return null;
+    }
+    _setActiveItem(item) {
+        const enabledItems = this._enabledItems();
+        const nextIndex = enabledItems.indexOf(item);
+        if (nextIndex < 0) {
+            return;
+        }
+        this.activeIndex = nextIndex;
+        this._syncRovingTabIndex();
     }
     _applyPositioning() {
         if (!this.open || !this.menuListElement) {
@@ -9223,13 +7330,14 @@ class Menu extends i$1 {
         if (!anchorEl) {
             return;
         }
-        this._surfaceController.start({
-            reference: anchorEl,
-            floating: this.menuListElement,
+        this._floatingController.setOptions({
             placement: this.placement,
             offset: this.offset,
             strategy: 'fixed',
+            closeOnClickOutside: !this.stayOpenOnOutsideClick,
         });
+        this._floatingController.setElements(anchorEl, this.menuListElement);
+        this._floatingController.open();
     }
     updated(changedProperties) {
         if (changedProperties.has('anchor') || changedProperties.has('open')) {
@@ -9246,7 +7354,7 @@ class Menu extends i$1 {
                 this._applyPositioning();
             }
             else {
-                this._surfaceController.stop();
+                this._floatingController.close();
                 const reason = this._closeReason;
                 this.dispatchEvent(new CustomEvent('close-menu', {
                     bubbles: true,
@@ -9261,7 +7369,8 @@ class Menu extends i$1 {
                     composed: true,
                     detail: { reason },
                 }));
-                if (!this.isSubmenu) {
+                const shouldRestoreFocus = reason.kind !== 'keydown' || reason.key !== 'Tab';
+                if (!this.isSubmenu && shouldRestoreFocus) {
                     this._lastFocusedElement?.focus();
                 }
             }
@@ -9276,7 +7385,7 @@ class Menu extends i$1 {
     }
     render() {
         return b `<div
-      class=${e$3({
+      class=${e$1({
             'menu': true,
             open: !this.preview && this.open,
             closed: !this.preview && !this.open,
@@ -9327,7 +7436,7 @@ __decorate([
     r()
 ], Menu.prototype, "activeIndex", void 0);
 __decorate([
-    e$4('.menu')
+    e$2('.menu')
 ], Menu.prototype, "menuListElement", void 0);
 
 var css_248z$g = i`* {
@@ -9539,10 +7648,10 @@ __decorate([
     n({ type: String, attribute: 'menu-corner' })
 ], SubMenu.prototype, "menuCorner", void 0);
 __decorate([
-    o$1({ slot: 'item' })
+    o({ slot: 'item' })
 ], SubMenu.prototype, "_items", void 0);
 __decorate([
-    o$1({ slot: 'menu' })
+    o({ slot: 'menu' })
 ], SubMenu.prototype, "_menus", void 0);
 
 var css_248z$f = i`@charset "UTF-8";
@@ -10216,7 +8325,7 @@ class Tab extends i$1 {
         if (!isLink) {
             return b `<button
           id="button"
-              class=${e$3(cssClasses)}
+              class=${e$1(cssClasses)}
               tabindex="0"
               @mousedown=${this.__handlePress}
               @keydown=${this.__handlePress}
@@ -10230,7 +8339,7 @@ class Tab extends i$1 {
             </button>`;
         }
         return b `<a
-        class=${e$3(cssClasses)}
+        class=${e$1(cssClasses)}
         id="button"
         tabindex="0"
         href=${this.href}
@@ -10396,7 +8505,7 @@ __decorate([
     r()
 ], Tab.prototype, "isPressed", void 0);
 __decorate([
-    e$4('.tab-element')
+    e$2('.tab-element')
 ], Tab.prototype, "tabElement", void 0);
 
 var css_248z$d = i`* {
@@ -11104,7 +9213,7 @@ class Slider extends i$1 {
           @touchstart=${this.onMouseDown}
         >
           <div class="track">
-            <div class="track-active" style=${o$2({ width: `${percentage}%` })}></div>
+            <div class="track-active" style=${o$1({ width: `${percentage}%` })}></div>
           </div>
 
           <div 
@@ -11116,7 +9225,7 @@ class Slider extends i$1 {
             aria-valuemax=${this.max}
             aria-valuenow=${this.value}
             aria-disabled=${this.disabled}
-            style=${o$2({ left: `calc(${percentage}% - var(--thumb-half))` })}
+            style=${o$1({ left: `calc(${percentage}% - var(--thumb-half))` })}
             @keydown=${this.handleKeyDown}
           >
             ${this.labeled ? b `<div class="value-label">${this.value}</div>` : ''}
@@ -11154,10 +9263,10 @@ __decorate([
     r()
 ], Slider.prototype, "isDragging", void 0);
 __decorate([
-    e$4('.slider-container')
+    e$2('.slider-container')
 ], Slider.prototype, "container", void 0);
 __decorate([
-    e$4('.thumb')
+    e$2('.thumb')
 ], Slider.prototype, "thumbElement", void 0);
 
 var css_248z$9 = i`* {
@@ -11457,7 +9566,7 @@ class Table extends i$1 {
         return total;
     }
     getTotalItems() {
-        if (this.paginate && !this.managed)
+        if (this.paginate && !this.managed && this.data)
             return this.data.length;
         return this.totalItems ?? 0;
     }
@@ -11509,7 +9618,7 @@ class Table extends i$1 {
                 : DEFAULT_CELL_WIDTH;
             const colEl = b `
         <div
-          class=${e$3({ col: true, sort: this.sortBy === col.name })}
+          class=${e$1({ col: true, sort: this.sortBy === col.name })}
           style="width: ${colWidth}rem"
         >
           <div class="col-content">
@@ -11589,7 +9698,7 @@ class Table extends i$1 {
                 const colEl = b `
           <div
             tabindex="0"
-            class=${e$3({
+            class=${e$1({
                     col: true,
                     'col-hover': this.hoveredCell.row === row &&
                         this.hoveredCell.column === column,
@@ -11615,7 +9724,7 @@ class Table extends i$1 {
             <div class="col-content">
               ${column.template
                     ? b `<div class="col-template">
-                    ${o$4(column.template(row, column))}
+                    ${o$3(column.template(row, column))}
                   </div>`
                     : b `<div class="col-text" title=${row?.[column.name] ?? ''}>
                     ${row?.[column.name]}
@@ -11632,7 +9741,7 @@ class Table extends i$1 {
             });
             return b `
         <div
-          class=${e$3({
+          class=${e$1({
                 row: true,
                 'row-hover': this.hoveredCell.row === row,
             })}
@@ -11684,10 +9793,10 @@ class Table extends i$1 {
             'horizontal-scrolled': this.isHorizontallyScrolled,
         };
         return b `
-      <div class=${e$3(tableClasses)}>
+      <div class=${e$1(tableClasses)}>
         <div class="table-scroll-container" @scroll=${this.onScrollContainer}>
           ${this.renderHeader()}
-          ${this.data.length ? this.renderBody() : this.renderEmptyState()}
+          ${this.data && this.data.length ? this.renderBody() : this.renderEmptyState()}
         </div>
         <div class="table-footer">${this.renderPagination()}</div>
       </div>
@@ -12164,7 +10273,7 @@ class SidebarMenuItem extends i$1 {
         this._nativeElement?.blur();
     }
     render() {
-        const classes = e$3({
+        const classes = e$1({
             'sidebar-menu-item': true,
             disabled: this.disabled,
             selected: this.selected,
@@ -12241,7 +10350,7 @@ __decorate([
     n({ type: Number, reflect: true })
 ], SidebarMenuItem.prototype, "level", void 0);
 __decorate([
-    e$4('.sidebar-menu-item-content')
+    e$2('.sidebar-menu-item-content')
 ], SidebarMenuItem.prototype, "_nativeElement", void 0);
 
 var css_248z$6 = i`* {
@@ -12452,15 +10561,15 @@ class SidebarSubMenu extends i$1 {
     }
     render() {
         const hasChildren = this._getChildNodes().length > 0;
-        const wrapperClasses = e$3({
+        const wrapperClasses = e$1({
             'sidebar-sub-menu': true,
         });
-        const innerClasses = e$3({
+        const innerClasses = e$1({
             'sidebar-sub-menu-inner': true,
             disabled: this.disabled,
             selected: this.selected,
         });
-        const inlineStyles = o$2({
+        const inlineStyles = o$1({
             paddingLeft: `calc(var(--sidebar-menu-item-height, 2.5rem) * ${this.level})`,
         });
         return b `
@@ -12525,7 +10634,7 @@ __decorate([
     n({ type: Number, reflect: true })
 ], SidebarSubMenu.prototype, "level", void 0);
 __decorate([
-    e$4('.sidebar-sub-menu-inner')
+    e$2('.sidebar-sub-menu-inner')
 ], SidebarSubMenu.prototype, "_nativeElement", void 0);
 
 var css_248z$5 = i`* {
@@ -12944,7 +11053,7 @@ class Snackbar extends i$1 {
         const liveRole = this.actionLabel || this.showCloseIcon ? 'alert' : 'status';
         return b `
       <div
-        class=${e$3({
+        class=${e$1({
             snackbar: true,
             open: !this.preview && this.open,
             preview: this.preview,
@@ -13372,7 +11481,7 @@ class Radio extends i$1 {
             'has-content': this.slotHasContent,
         };
         return b `
-      <label class=${e$3(cssClasses)}>
+      <label class=${e$1(cssClasses)}>
         <div
           class="container"
           tabindex=${this.isGroupFocusTarget
@@ -13455,10 +11564,10 @@ __decorate([
     r()
 ], Radio.prototype, "isGroupFocusTarget", void 0);
 __decorate([
-    e$4('.container')
+    e$2('.container')
 ], Radio.prototype, "containerElement", void 0);
 __decorate([
-    e$4('.input-native')
+    e$2('.input-native')
 ], Radio.prototype, "nativeElement", void 0);
 
 var css_248z$2 = i`@charset "UTF-8";
@@ -13708,7 +11817,7 @@ __decorate([
     n({ type: Boolean, reflect: true })
 ], SelectOptionElement.prototype, "filtered", void 0);
 __decorate([
-    e$4('wc-menu-item')
+    e$2('wc-menu-item')
 ], SelectOptionElement.prototype, "_menuItemEl", void 0);
 
 /**
@@ -14080,7 +12189,7 @@ class Select extends BaseInput {
     _renderFieldEnd() {
         return b `
       <wc-icon
-        class=${e$3({
+        class=${e$1({
             'dropdown-icon': true,
             'dropdown-icon--open': this._open,
         })}
@@ -14190,10 +12299,10 @@ __decorate([
     r()
 ], Select.prototype, "_noOptionsVisible", void 0);
 __decorate([
-    e$4('.select-trigger')
+    e$2('.select-trigger')
 ], Select.prototype, "_triggerEl", void 0);
 __decorate([
-    e$4('.search-input')
+    e$2('.search-input')
 ], Select.prototype, "_searchInputEl", void 0);
 
 var css_248z$1 = i`* {
@@ -14611,7 +12720,7 @@ class NavigationRailItem extends i$1 {
         if (!isLink) {
             return b `<button
         id="item"
-        class=${e$3(cssClasses)}
+        class=${e$1(cssClasses)}
         ?disabled=${this.disabled}
         aria-disabled=${`${this.disabled}`}
         aria-current=${this.active ? 'page' : A}
@@ -14626,7 +12735,7 @@ class NavigationRailItem extends i$1 {
         }
         return b `<a
       id="item"
-      class=${e$3(cssClasses)}
+      class=${e$1(cssClasses)}
       href=${this.href}
       target=${this.target}
       aria-current=${this.active ? 'page' : A}
@@ -14677,7 +12786,7 @@ __decorate([
     r()
 ], NavigationRailItem.prototype, "_hasActiveIcon", void 0);
 __decorate([
-    e$4('.item-element')
+    e$2('.item-element')
 ], NavigationRailItem.prototype, "itemElement", void 0);
 
 /**
@@ -14793,7 +12902,7 @@ class NavigationRail extends i$1 {
             [`mode-${this.mode}`]: true,
         };
         return b `
-      <div class=${e$3(cssClasses)}>
+      <div class=${e$1(cssClasses)}>
         <div class="header">
           <slot name="header"></slot>
         </div>
@@ -14817,5 +12926,5 @@ __decorate([
     n({ type: Boolean, attribute: 'show-divider' })
 ], NavigationRail.prototype, "showDivider", void 0);
 
-export { Accordion as A, Badge as B, Checkbox as C, DatePicker as D, Elevation as E, Field as F, SubMenu as G, Switch as H, Icon as I, TabGroup as J, TabPanel as K, LinearProgress as L, Menu as M, NavigationRail as N, Table as O, Pagination as P, Tabs as Q, Radio as R, SegmentedButton as S, Tab as T, Tag as U, Textarea as V, TimePicker as W, Tooltip as X, UrlField as Y, Avatar as a, Breadcrumb as b, BreadcrumbItem as c, Chip as d, CircularProgress as e, Container as f, Divider as g, EmptyState as h, FocusRing as i, Image as j, Input as k, Link as l, MenuItem as m, NavigationRailItem as n, NumberField as o, Ripple as p, SegmentedButtonGroup as q, Select as r, SelectOptionElement as s, SidebarMenu as t, SidebarMenuItem as u, SidebarSubMenu as v, Skeleton as w, Slider as x, Snackbar as y, Spinner as z };
-//# sourceMappingURL=navigation-rail-Lxetd5-Z.js.map
+export { Accordion as A, Badge as B, Checkbox as C, DatePicker as D, Elevation as E, Field as F, Switch as G, TabGroup as H, Image as I, TabPanel as J, Table as K, LinearProgress as L, Menu as M, NavigationRail as N, Tabs as O, Pagination as P, Tag as Q, Radio as R, SegmentedButton as S, Tab as T, Textarea as U, TimePicker as V, Tooltip as W, UrlField as X, Avatar as a, Breadcrumb as b, BreadcrumbItem as c, Chip as d, CircularProgress as e, Container as f, Divider as g, EmptyState as h, FocusRing as i, Input as j, Link as k, MenuItem as l, NavigationRailItem as m, NumberField as n, Ripple as o, SegmentedButtonGroup as p, Select as q, SelectOptionElement as r, SidebarMenu as s, SidebarMenuItem as t, SidebarSubMenu as u, Skeleton as v, Slider as w, Snackbar as x, Spinner as y, SubMenu as z };
+//# sourceMappingURL=navigation-rail-DyO0oAZU.js.map