@bcgov/design-system-react-components 0.8.1-pr944 → 0.8.1-pr950

package/dist/esm/index.js

@@ -730,7 +730,7 @@ function $23f2114a1b82827e$export$4282f70798064fe0(node, otherNode) {
     if (!($6a20a7989e6c817a$export$98658e8c59125e6a)()) return otherNode && node ? node.contains(otherNode) : false;
     if (!node || !otherNode) return false;
     let currentNode = otherNode;
-    while(currentNode !== null){
+    while(currentNode != null){
         if (currentNode === node) return true;
         if (typeof currentNode.assignedElements !== 'function' && currentNode.assignedSlot?.parentNode) // Element is slotted
         currentNode = currentNode.assignedSlot.parentNode;
@@ -833,57 +833,9 @@ function $b72f3f7b3b5f42c6$export$759df0d867455a91(document) {
  * OF ANY KIND, either express or implied. See the License for the specific language
  * governing permissions and limitations under the License.
  */ function $1969ac565cfec8d0$export$de79e2c695e052f3(element) {
-    if ($1969ac565cfec8d0$var$supportsPreventScroll()) element.focus({
+    element.focus({
         preventScroll: true
     });
-    else {
-        let scrollableElements = $1969ac565cfec8d0$var$getScrollableElements(element);
-        element.focus();
-        $1969ac565cfec8d0$var$restoreScrollPosition(scrollableElements);
-    }
-}
-let $1969ac565cfec8d0$var$supportsPreventScrollCached = null;
-function $1969ac565cfec8d0$var$supportsPreventScroll() {
-    if ($1969ac565cfec8d0$var$supportsPreventScrollCached == null) {
-        $1969ac565cfec8d0$var$supportsPreventScrollCached = false;
-        try {
-            let focusElem = document.createElement('div');
-            focusElem.focus({
-                get preventScroll () {
-                    $1969ac565cfec8d0$var$supportsPreventScrollCached = true;
-                    return true;
-                }
-            });
-        } catch  {
-        // Ignore
-        }
-    }
-    return $1969ac565cfec8d0$var$supportsPreventScrollCached;
-}
-function $1969ac565cfec8d0$var$getScrollableElements(element) {
-    let parent = element.parentNode;
-    let scrollableElements = [];
-    let rootScrollingElement = document.scrollingElement || document.documentElement;
-    while(parent instanceof HTMLElement && parent !== rootScrollingElement){
-        if (parent.offsetHeight < parent.scrollHeight || parent.offsetWidth < parent.scrollWidth) scrollableElements.push({
-            element: parent,
-            scrollTop: parent.scrollTop,
-            scrollLeft: parent.scrollLeft
-        });
-        parent = parent.parentNode;
-    }
-    if (rootScrollingElement instanceof HTMLElement) scrollableElements.push({
-        element: rootScrollingElement,
-        scrollTop: rootScrollingElement.scrollTop,
-        scrollLeft: rootScrollingElement.scrollLeft
-    });
-    return scrollableElements;
-}
-function $1969ac565cfec8d0$var$restoreScrollPosition(scrollableElements) {
-    for (let { element: element, scrollTop: scrollTop, scrollLeft: scrollLeft } of scrollableElements){
-        element.scrollTop = scrollTop;
-        element.scrollLeft = scrollLeft;
-    }
 }
 
 /*
@@ -1080,10 +1032,10 @@ function $a92dc41f639950be$export$cabe61c495ee3649(target) {
     let root = targetRoot != null && ($d447af545b77c9f1$export$af51f0f06c0f328a)(targetRoot) ? targetRoot : ($d447af545b77c9f1$export$f21a1ffae260145a)(target);
     // Focus is "moving to target" when it moves to the button or to a descendant of the button
     // (e.g. SVG icon)
-    let isFocusMovingToTarget = (focusTarget)=>focusTarget === target || focusTarget != null && ($23f2114a1b82827e$export$4282f70798064fe0)(target, focusTarget);
+    let isFocusMovingToTarget = (focusTarget)=>focusTarget === target || ($d447af545b77c9f1$export$8ee0fc9ee280b4ee)(focusTarget) && ($23f2114a1b82827e$export$4282f70798064fe0)(target, focusTarget);
     // Blur/focusout events have their target as the element losing focus. Stop propagation when
     // that is the previously focused element (activeElement) or a descendant (e.g. in shadow DOM).
-    let isBlurFromActiveElement = (eventTarget)=>eventTarget === activeElement || activeElement != null && eventTarget != null && ($23f2114a1b82827e$export$4282f70798064fe0)(activeElement, eventTarget);
+    let isBlurFromActiveElement = (eventTarget)=>eventTarget === activeElement || activeElement != null && ($d447af545b77c9f1$export$8ee0fc9ee280b4ee)(eventTarget) && ($23f2114a1b82827e$export$4282f70798064fe0)(activeElement, eventTarget);
     $a92dc41f639950be$export$fda7da73ab5d4c48 = true;
     let isRefocusing = false;
     let onBlur = (e)=>{
@@ -1250,14 +1202,6 @@ function $caaf0dd3060ed57c$export$efa8c9099e530235(link, modifiers) {
 }
 function $caaf0dd3060ed57c$export$95185d699e05d4d7(target, modifiers, setOpening = true) {
     let { metaKey: metaKey, ctrlKey: ctrlKey, altKey: altKey, shiftKey: shiftKey } = modifiers;
-    // Firefox does not recognize keyboard events as a user action by default, and the popup blocker
-    // will prevent links with target="_blank" from opening. However, it does allow the event if the
-    // Command/Control key is held, which opens the link in a background tab. This seems like the best we can do.
-    // See https://bugzilla.mozilla.org/show_bug.cgi?id=257870 and https://bugzilla.mozilla.org/show_bug.cgi?id=746640.
-    if (!($2add3ce32c6007eb$export$78551043582a6a98)() && ($2add3ce32c6007eb$export$b7d78993b74f766d)() && window.event?.type?.startsWith('key') && target.target === '_blank') {
-        if (($2add3ce32c6007eb$export$9ac100e40613ea10)()) metaKey = true;
-        else ctrlKey = true;
-    }
     // WebKit does not support firing click events with modifier keys, but does support keyboard events.
     // https://github.com/WebKit/WebKit/blob/c03d0ac6e6db178f90923a0a63080b5ca210d25f/Source/WebCore/html/HTMLAnchorElement.cpp#L184
     let event = ($2add3ce32c6007eb$export$78551043582a6a98)() && ($2add3ce32c6007eb$export$9ac100e40613ea10)() && !($2add3ce32c6007eb$export$7bef049ce92e4224)() && process.env.NODE_ENV !== 'test' ? new KeyboardEvent('keydown', {
@@ -1437,6 +1381,15 @@ function $8f5a2122b0992be3$var$handleWindowBlur() {
     $8f5a2122b0992be3$var$hasEventBeforeFocus = false;
     $8f5a2122b0992be3$var$hasBlurredWindowRecently = true;
 }
+function $8f5a2122b0992be3$var$handleInvalidEvent(e) {
+    let startingActiveElement = ($23f2114a1b82827e$export$cd4e5573fbe2b576)(($d447af545b77c9f1$export$b204af158042fbac)(($23f2114a1b82827e$export$e58f029f0fbfdb29)(e)));
+    queueMicrotask(()=>{
+        // If focus was moved to a different element after the form became invalid,
+        // then it was likely a forms library that moved focus to the first invalid field.
+        // In this case, we want to set the modality to keyboard.
+        if (($23f2114a1b82827e$export$cd4e5573fbe2b576)(($d447af545b77c9f1$export$b204af158042fbac)(($23f2114a1b82827e$export$e58f029f0fbfdb29)(e))) !== startingActiveElement) $8f5a2122b0992be3$export$8397ddfc504fdb9a('keyboard');
+    });
+}
 /**
  * Setup global event listeners to control when keyboard focus style should be visible.
  */ function $8f5a2122b0992be3$var$setupGlobalFocusEvents(element) {
@@ -1464,6 +1417,7 @@ function $8f5a2122b0992be3$var$handleWindowBlur() {
     documentObject.addEventListener('keydown', $8f5a2122b0992be3$var$handleKeyboardEvent, true);
     documentObject.addEventListener('keyup', $8f5a2122b0992be3$var$handleKeyboardEvent, true);
     documentObject.addEventListener('click', $8f5a2122b0992be3$var$handleClickEvent, true);
+    documentObject.addEventListener('invalid', $8f5a2122b0992be3$var$handleInvalidEvent, true);
     // Register focus events on the window so they are sure to happen
     // before React's event listeners (registered on the document).
     windowObject.addEventListener('focus', $8f5a2122b0992be3$var$handleFocusEvent, true);
@@ -1500,6 +1454,7 @@ const $8f5a2122b0992be3$var$tearDownWindowFocusTracking = (element, loadListener
     documentObject.removeEventListener('keydown', $8f5a2122b0992be3$var$handleKeyboardEvent, true);
     documentObject.removeEventListener('keyup', $8f5a2122b0992be3$var$handleKeyboardEvent, true);
     documentObject.removeEventListener('click', $8f5a2122b0992be3$var$handleClickEvent, true);
+    documentObject.removeEventListener('invalid', $8f5a2122b0992be3$var$handleInvalidEvent, true);
     windowObject.removeEventListener('focus', $8f5a2122b0992be3$var$handleFocusEvent, true);
     windowObject.removeEventListener('blur', $8f5a2122b0992be3$var$handleWindowBlur, false);
     if (typeof PointerEvent !== 'undefined') {
@@ -1598,7 +1553,7 @@ function $8f5a2122b0992be3$export$ec71b4b83ac08ec3(fn, deps, opts) {
 }
 
 /*
- * Copyright 2024 Adobe. All rights reserved.
+ * Copyright 2026 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License. You may obtain a copy
  * of the License at http://www.apache.org/licenses/LICENSE-2.0
@@ -1608,10 +1563,50 @@ function $8f5a2122b0992be3$export$ec71b4b83ac08ec3(fn, deps, opts) {
  * OF ANY KIND, either express or implied. See the License for the specific language
  * governing permissions and limitations under the License.
  */ 
-function $bb39c0fc1c19b34c$export$16792effe837dba3(e) {
-    if (($2add3ce32c6007eb$export$9ac100e40613ea10)()) return e.metaKey;
-    return e.ctrlKey;
+function $7096878c21af5e66$export$a929f3f93e2cc67e(key, doc) {
+    let ownerWindow = ($d447af545b77c9f1$export$f21a1ffae260145a)(doc);
+    let ownerDocument = ($d447af545b77c9f1$export$b204af158042fbac)(doc);
+    if (ownerDocument == null || ownerWindow == null) return;
+    let content = undefined;
+    let selector = `meta[name="${CSS.escape(key)}"], meta[property="${CSS.escape(key)}"]`;
+    let meta = ownerDocument.querySelector(selector);
+    if (meta && meta instanceof ownerWindow.HTMLMetaElement) {
+        if (key === 'csp-nonce' && meta.nonce) content ??= meta.nonce || undefined;
+        if (meta.content) content ??= meta.content || undefined;
+    }
+    if (key === 'csp-nonce') content ??= ownerWindow.__webpack_nonce__ || globalThis.__webpack_nonce__ || undefined;
+    return content;
 }
+
+/*
+ * Copyright 2024 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+
+
+const $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT = 100;
+const $bb39c0fc1c19b34c$var$KEYBOARD_TIMEOUT = 600;
+// Tracks layout state of the on-screen keyboard.
+const $bb39c0fc1c19b34c$var$state = {
+    isOpen: false,
+    screenWidth: 0,
+    screenHeight: 0,
+    screenAngle: 0,
+    screenTimeout: 0,
+    startTimeStamp: 0,
+    endTimeStamp: 0,
+    resizeTimeStamp: 0,
+    resizeTimeout: 0
+};
 // HTML input types that do not cause the software keyboard to appear.
 const $bb39c0fc1c19b34c$var$nonTextInputTypes = new Set([
     'checkbox',
@@ -1624,8 +1619,181 @@ const $bb39c0fc1c19b34c$var$nonTextInputTypes = new Set([
     'submit',
     'reset'
 ]);
+if (process.env.NODE_ENV === 'test' && typeof window !== 'undefined' && !Reflect.has(window, 'visualViewport')) {
+    const visualViewport = Object.assign(new EventTarget(), {
+        offsetTop: 0,
+        offsetLeft: 0,
+        pageTop: 0,
+        pageLeft: 0,
+        scale: 1
+    });
+    Reflect.defineProperty(visualViewport, 'width', {
+        get: ()=>window.innerWidth,
+        configurable: true
+    });
+    Reflect.defineProperty(visualViewport, 'height', {
+        get: ()=>window.innerHeight,
+        configurable: true
+    });
+    Reflect.defineProperty(window, 'visualViewport', {
+        value: visualViewport,
+        configurable: true,
+        writable: true
+    });
+}
+if (process.env.NODE_ENV === 'test' && typeof window !== 'undefined' && !Reflect.has(window.screen, 'orientation')) {
+    const orientation = Object.assign(new EventTarget(), {
+        type: 'landscape-primary'
+    });
+    Reflect.defineProperty(window.screen, 'orientation', {
+        value: orientation,
+        configurable: true,
+        writable: true
+    });
+    Reflect.defineProperty(window.screen.orientation, 'angle', {
+        get: ()=>window.orientation ?? 0,
+        configurable: true
+    });
+}
+function $bb39c0fc1c19b34c$var$getTouchScreen() {
+    // Normalize the screen by any scaling to get the layout coordinate space.
+    let screenWidth = Number(window.visualViewport?.width ?? window.innerWidth);
+    let screenHeight = Number(window.visualViewport?.height ?? window.innerHeight);
+    let visualScale = Number(window.visualViewport?.scale ?? 1);
+    return {
+        width: screenWidth * visualScale,
+        height: screenHeight * visualScale,
+        angle: window.screen.orientation?.angle ?? 0
+    };
+}
+function $bb39c0fc1c19b34c$var$onResizeStart(e) {
+    // So we don't constantly call clearTimeout and setTimeout, keep track of the
+    // current timeout time and only reschedule the timer when it is getting close.
+    if ($bb39c0fc1c19b34c$var$state.resizeTimeStamp <= e.timeStamp + 50) {
+        $bb39c0fc1c19b34c$var$state.resizeTimeStamp = e.timeStamp + 150;
+        window.clearTimeout($bb39c0fc1c19b34c$var$state.resizeTimeout);
+        $bb39c0fc1c19b34c$var$state.resizeTimeout = window.setTimeout($bb39c0fc1c19b34c$var$onResizeEnd, 150);
+    }
+}
+function $bb39c0fc1c19b34c$var$onResizeEnd() {
+    let viewportMeta = ($7096878c21af5e66$export$a929f3f93e2cc67e)('viewport');
+    // Overlaying keyboards do not impact geometry, so there is nothing to measure.
+    // https://caniuse.com/mdn-html_elements_meta_name_viewport_interactive-widget
+    if (($2add3ce32c6007eb$export$a11b0059900ceec8)() && viewportMeta?.includes('overlays-content')) return;
+    let time = performance.now();
+    let screen = $bb39c0fc1c19b34c$var$getTouchScreen();
+    let elapsed = time - $bb39c0fc1c19b34c$var$state.startTimeStamp;
+    let delta = $bb39c0fc1c19b34c$var$state.screenHeight - screen.height;
+    let rotation = $bb39c0fc1c19b34c$var$state.screenAngle - screen.angle;
+    // Update the screen once an open keyboard that rotated along closes. The state swap was
+    // deferred, so the old width predicts the height it should close towards.
+    if (Math.abs(rotation) % 180 && $bb39c0fc1c19b34c$var$state.screenWidth - screen.height < $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT) {
+        $bb39c0fc1c19b34c$var$state.screenWidth = screen.width;
+        $bb39c0fc1c19b34c$var$state.screenHeight = screen.height;
+        $bb39c0fc1c19b34c$var$state.screenAngle = screen.angle;
+        delta = 0;
+    }
+    // Update the screen if a resize happens outside the capture timeframe. We debounce
+    // because WebKit may fire its single opening resize before the focus event.
+    if (elapsed > $bb39c0fc1c19b34c$var$KEYBOARD_TIMEOUT) {
+        window.clearTimeout($bb39c0fc1c19b34c$var$state.screenTimeout);
+        $bb39c0fc1c19b34c$var$state.screenTimeout = window.setTimeout(()=>{
+            let activeElement = document.hasFocus() ? ($23f2114a1b82827e$export$cd4e5573fbe2b576)() : null;
+            let willKeyboardOpen = $bb39c0fc1c19b34c$export$c57958e35f31ed73(activeElement);
+            let screen = $bb39c0fc1c19b34c$var$getTouchScreen();
+            if (Math.abs($bb39c0fc1c19b34c$var$state.screenAngle - screen.angle) % 180) return;
+            if ($bb39c0fc1c19b34c$var$state.isOpen && willKeyboardOpen) return;
+            $bb39c0fc1c19b34c$var$state.screenWidth = screen.width;
+            $bb39c0fc1c19b34c$var$state.screenHeight = screen.height;
+            $bb39c0fc1c19b34c$var$state.screenAngle = screen.angle;
+            $bb39c0fc1c19b34c$var$state.isOpen = false;
+        }, $bb39c0fc1c19b34c$var$KEYBOARD_TIMEOUT);
+    }
+    // Otherwise, record an opening if the height changed by more than our threshold.
+    // This may fail if the layout viewport changes for other reasons during this timeframe.
+    if (elapsed <= $bb39c0fc1c19b34c$var$KEYBOARD_TIMEOUT && delta >= $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT) $bb39c0fc1c19b34c$var$state.endTimeStamp = time;
+    // Store the new open state since the viewport is stable when this is reached.
+    $bb39c0fc1c19b34c$var$state.isOpen = delta >= $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT;
+}
+function $bb39c0fc1c19b34c$var$onOrientationChange() {
+    let screen = $bb39c0fc1c19b34c$var$getTouchScreen();
+    let rotation = $bb39c0fc1c19b34c$var$state.screenAngle - screen.angle;
+    // Rotation may cause the resize buffer to be filled, but we need to make sure a screen
+    // estimate is already available in case focus lands before it expires. This could fail
+    // if a top bar exceeds the keyboard threshold, in which case we may need to revisit.
+    if (Math.abs(rotation) % 180 && !$bb39c0fc1c19b34c$var$state.isOpen) {
+        let width = $bb39c0fc1c19b34c$var$state.screenWidth;
+        let height = $bb39c0fc1c19b34c$var$state.screenHeight;
+        $bb39c0fc1c19b34c$var$state.screenWidth = height;
+        $bb39c0fc1c19b34c$var$state.screenHeight = width;
+    }
+    if (!$bb39c0fc1c19b34c$var$state.isOpen) $bb39c0fc1c19b34c$var$state.screenAngle = screen.angle;
+}
+function $bb39c0fc1c19b34c$var$onFocus(e) {
+    let target = ($23f2114a1b82827e$export$e58f029f0fbfdb29)(e);
+    let willKeyboardOpen = $bb39c0fc1c19b34c$export$c57958e35f31ed73(target);
+    let time = performance.now();
+    let screen = $bb39c0fc1c19b34c$var$getTouchScreen();
+    let delta = $bb39c0fc1c19b34c$var$state.screenHeight - screen.height;
+    // Update the screen and start the timer if we are about to open.
+    if (delta < $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT && willKeyboardOpen) {
+        $bb39c0fc1c19b34c$var$state.screenWidth = screen.width;
+        $bb39c0fc1c19b34c$var$state.screenHeight = screen.height;
+        $bb39c0fc1c19b34c$var$state.screenAngle = screen.angle;
+        $bb39c0fc1c19b34c$var$state.startTimeStamp = time;
+    }
+    // This focus will open a keyboard so reset the buffer.
+    if (willKeyboardOpen) window.clearTimeout($bb39c0fc1c19b34c$var$state.screenTimeout);
+    // Stop the timer if the keyboard is already open.
+    if (delta >= $bb39c0fc1c19b34c$var$KEYBOARD_HEIGHT && willKeyboardOpen) $bb39c0fc1c19b34c$var$state.endTimeStamp = time;
+}
+function $bb39c0fc1c19b34c$var$setupGlobalEvents() {
+    let screen = $bb39c0fc1c19b34c$var$getTouchScreen();
+    // WebKit only fires a single event per resize.
+    ($d447af545b77c9f1$export$f531f92e2a15358f)(window.visualViewport, 'resize', ($2add3ce32c6007eb$export$78551043582a6a98)() ? $bb39c0fc1c19b34c$var$onResizeEnd : $bb39c0fc1c19b34c$var$onResizeStart);
+    // oxlint-disable-next-line - looks like the lint for this is a little too aggressive
+    ($d447af545b77c9f1$export$f531f92e2a15358f)(window.screen.orientation, 'change', $bb39c0fc1c19b34c$var$onOrientationChange);
+    ($d447af545b77c9f1$export$f531f92e2a15358f)(window, 'focus', $bb39c0fc1c19b34c$var$onFocus, {
+        capture: true,
+        passive: true
+    });
+    // Store the initial screen dimensions.
+    $bb39c0fc1c19b34c$var$state.screenWidth = screen.width;
+    $bb39c0fc1c19b34c$var$state.screenHeight = screen.height;
+    $bb39c0fc1c19b34c$var$state.screenAngle = screen.angle;
+}
+if (typeof document !== 'undefined') {
+    if (document.readyState !== 'loading') $bb39c0fc1c19b34c$var$setupGlobalEvents();
+    else ($d447af545b77c9f1$export$f531f92e2a15358f)(document, 'DOMContentLoaded', $bb39c0fc1c19b34c$var$setupGlobalEvents);
+}
+function $bb39c0fc1c19b34c$export$a986ed8aea890397() {
+    let viewportMeta = ($7096878c21af5e66$export$a929f3f93e2cc67e)('viewport');
+    // Overlaying keyboards do not impact geometry, so there is nothing to await.
+    // https://caniuse.com/mdn-html_elements_meta_name_viewport_interactive-widget
+    if (($2add3ce32c6007eb$export$a11b0059900ceec8)() && viewportMeta?.includes('overlays-content')) return false;
+    // WebKit may resize before focus, but an open keyboard always means we have support.
+    if ($bb39c0fc1c19b34c$var$state.isOpen) return true;
+    // As long as no input has ever been focused, we return default support.
+    if (!$bb39c0fc1c19b34c$var$state.startTimeStamp) return window.navigator.maxTouchPoints > 0;
+    // If keyboard geometry changed within the timeout period, we have support.
+    if ($bb39c0fc1c19b34c$var$state.endTimeStamp >= $bb39c0fc1c19b34c$var$state.startTimeStamp) return true;
+    // If a geometry change is mid-flight we return the most recent support.
+    // Supported platforms may have a hardware keyboard, which this won't catch, but thats
+    // about as far as we can reasonably go to exclude non-touch devices.
+    return performance.now() - $bb39c0fc1c19b34c$var$state.startTimeStamp <= $bb39c0fc1c19b34c$var$KEYBOARD_TIMEOUT ? $bb39c0fc1c19b34c$var$state.endTimeStamp > 0 || window.navigator.maxTouchPoints > 0 : false;
+}
 function $bb39c0fc1c19b34c$export$c57958e35f31ed73(target) {
-    return target instanceof HTMLInputElement && !$bb39c0fc1c19b34c$var$nonTextInputTypes.has(target.type) || target instanceof HTMLTextAreaElement || target instanceof HTMLElement && target.isContentEditable;
+    if (!(target instanceof Element) || !($3b8b240c1bf84ab9$export$4c063cf1350e6fed)(target)) return false;
+    let isTextArea = target instanceof HTMLTextAreaElement;
+    let isEditable = target instanceof HTMLElement && target.isContentEditable;
+    let isTextInput = target instanceof HTMLInputElement && !$bb39c0fc1c19b34c$var$nonTextInputTypes.has(target.type);
+    return isTextArea || isEditable || isTextInput;
+}
+function $bb39c0fc1c19b34c$export$16792effe837dba3(event) {
+    return ($2add3ce32c6007eb$export$9ac100e40613ea10)() ? event.metaKey : event.ctrlKey;
+}
+function $bb39c0fc1c19b34c$export$b1f1c83775b8b5f7() {
+    return $bb39c0fc1c19b34c$var$state.isOpen;
 }
 
 /*
@@ -2074,7 +2242,7 @@ function $cf2482eff2eeeec2$export$f12b703ca79dfbb1(strings, packageName) {
  * governing permissions and limitations under the License.
  */ 
 // Use the earliest effect possible to reset the ref below.
-const $3e6197669829fe11$var$useEarlyEffect = typeof document !== 'undefined' ? ($8WNJc$react)['useInsertionEffect'] ?? ($8WNJc$react).useLayoutEffect : ()=>{};
+const $3e6197669829fe11$var$useEarlyEffect = typeof document !== 'undefined' || parseInt(($8WNJc$react).version, 10) >= 19 ? ($8WNJc$react)['useInsertionEffect'] ?? ($8WNJc$react).useLayoutEffect : ()=>{};
 function $3e6197669829fe11$export$40bfa8c7b0832715(value, defaultValue, onChange) {
     // Store the value in both state and a ref. The state value will only be used when uncontrolled.
     // The ref is used to track the most current value, which is passed to the function setState callback.
@@ -2641,7 +2809,7 @@ class $96ead35620b8fd36$export$b34a105447964f9f extends $96ead35620b8fd36$export
     constructor(collection){
         // @ts-ignore
         super(null), this.nodeType = 11 // DOCUMENT_FRAGMENT_NODE
-        , this.ownerDocument = this, this.dirtyNodes = new Set(), this.isSSR = false, this.nodeId = 0, this.nodesByProps = new WeakMap(), this.nextCollection = null, this.subscriptions = new Set(), this.queuedRender = false, this.inSubscription = false;
+        , this.ownerDocument = this, this.dirtyNodes = new Set(), this.isSSR = false, this.nodeId = 0, this.nodesByProps = new WeakMap(), this.keyOwners = new Map(), this.nextCollection = null, this.subscriptions = new Set(), this.queuedRender = false, this.inSubscription = false;
         this.collection = collection;
         this.nextCollection = collection;
     }
@@ -2660,6 +2828,16 @@ class $96ead35620b8fd36$export$b34a105447964f9f extends $96ead35620b8fd36$export
     }
     addNode(element) {
         if (element.isHidden || element.node == null) return;
+        if (process.env.NODE_ENV !== 'production') {
+            // Two elements with the same key would corrupt the linked list of sibling keys, which
+            // silently drops items or makes key traversal loop forever. Removed and hidden elements
+            // release their key in removeNode before any node is added, so a different owner here
+            // is a live duplicate.
+            let key = element.node.key;
+            let owner = this.keyOwners.get(key);
+            if (owner && owner !== element) throw new Error(`Duplicate key "${String(key)}" found in collection. Every item in a collection must have a unique key.`);
+            this.keyOwners.set(key, element);
+        }
         let collection = this.getMutableCollection();
         if (!collection.getItem(element.node.key)) for (let child of element)this.addNode(child);
         collection.addNode(element.node);
@@ -2669,6 +2847,7 @@ class $96ead35620b8fd36$export$b34a105447964f9f extends $96ead35620b8fd36$export
         if (node.node) {
             let collection = this.getMutableCollection();
             collection.removeNode(node.node.key);
+            if (process.env.NODE_ENV !== 'production' && this.keyOwners.get(node.node.key) === node) this.keyOwners.delete(node.node.key);
         }
     }
     /** Finalizes the collection update, updating all nodes and freezing the collection. */ getCollection() {
@@ -2732,6 +2911,7 @@ class $96ead35620b8fd36$export$b34a105447964f9f extends $96ead35620b8fd36$export
             this.firstChild = null;
             this.lastChild = null;
             this.nodeId = 0;
+            this.keyOwners.clear();
         }
     }
 }
@@ -2818,62 +2998,57 @@ function $a80bd3e9349588e7$var$isWeakKey(value) {
  * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
  * OF ANY KIND, either express or implied. See the License for the specific language
  * governing permissions and limitations under the License.
- */ // We store a global list of elements that are currently transitioning,
+ */ 
+
+// We store a global list of elements that are currently transitioning,
 // mapped to a set of CSS properties that are transitioning for that element.
 // This is necessary rather than a simple count of transitions because of browser
 // bugs, e.g. Chrome sometimes fires both transitionend and transitioncancel rather
 // than one or the other. So we need to track what's actually transitioning so that
 // we can ignore these duplicate events.
-
-let $081cb5757e08788e$var$transitionsByElement = new Map();
-// A list of callbacks to call once there are no transitioning elements.
-let $081cb5757e08788e$var$transitionCallbacks = new Set();
-function $081cb5757e08788e$var$setupGlobalEvents() {
-    if (typeof window === 'undefined') return;
-    function isTransitionEvent(event) {
-        return 'propertyName' in event;
+const $081cb5757e08788e$var$transitionsByElement = new Map();
+const $081cb5757e08788e$var$transitionCallbacks = new Set();
+function $081cb5757e08788e$var$isTransitionEvent(event) {
+    return 'propertyName' in event;
+}
+function $081cb5757e08788e$var$onTransitionStart(e) {
+    let eventTarget = ($23f2114a1b82827e$export$e58f029f0fbfdb29)(e);
+    if (!$081cb5757e08788e$var$isTransitionEvent(e) || !eventTarget) return;
+    // Add the transitioning property to the list for this element.
+    let transitions = $081cb5757e08788e$var$transitionsByElement.get(eventTarget);
+    if (!transitions) {
+        transitions = new Set();
+        $081cb5757e08788e$var$transitionsByElement.set(eventTarget, transitions);
+        // The transitioncancel event must be registered on the element itself, rather than as a global
+        // event. This enables us to handle when the node is deleted from the document while it is transitioning.
+        // In that case, the cancel event would have nowhere to bubble to so we need to handle it directly.
+        eventTarget.addEventListener('transitioncancel', $081cb5757e08788e$var$onTransitionEnd, {
+            once: true
+        });
     }
-    let onTransitionStart = (e)=>{
-        let eventTarget = ($23f2114a1b82827e$export$e58f029f0fbfdb29)(e);
-        if (!isTransitionEvent(e) || !eventTarget) return;
-        // Add the transitioning property to the list for this element.
-        let transitions = $081cb5757e08788e$var$transitionsByElement.get(eventTarget);
-        if (!transitions) {
-            transitions = new Set();
-            $081cb5757e08788e$var$transitionsByElement.set(eventTarget, transitions);
-            // The transitioncancel event must be registered on the element itself, rather than as a global
-            // event. This enables us to handle when the node is deleted from the document while it is transitioning.
-            // In that case, the cancel event would have nowhere to bubble to so we need to handle it directly.
-            eventTarget.addEventListener('transitioncancel', onTransitionEnd, {
-                once: true
-            });
-        }
-        transitions.add(e.propertyName);
-    };
-    let onTransitionEnd = (e)=>{
-        let eventTarget = ($23f2114a1b82827e$export$e58f029f0fbfdb29)(e);
-        if (!isTransitionEvent(e) || !eventTarget) return;
-        // Remove property from list of transitioning properties.
-        let properties = $081cb5757e08788e$var$transitionsByElement.get(eventTarget);
-        if (!properties) return;
-        properties.delete(e.propertyName);
-        // If empty, remove transitioncancel event, and remove the element from the list of transitioning elements.
-        if (properties.size === 0) {
-            eventTarget.removeEventListener('transitioncancel', onTransitionEnd);
-            $081cb5757e08788e$var$transitionsByElement.delete(eventTarget);
-        }
-        // If no transitioning elements, call all of the queued callbacks.
-        if ($081cb5757e08788e$var$transitionsByElement.size === 0) {
-            for (let cb of $081cb5757e08788e$var$transitionCallbacks)cb();
-            $081cb5757e08788e$var$transitionCallbacks.clear();
-        }
-    };
-    document.body.addEventListener('transitionrun', onTransitionStart);
-    document.body.addEventListener('transitionend', onTransitionEnd);
+    transitions.add(e.propertyName);
 }
-if (typeof document !== 'undefined') {
-    if (document.readyState !== 'loading') $081cb5757e08788e$var$setupGlobalEvents();
-    else document.addEventListener('DOMContentLoaded', $081cb5757e08788e$var$setupGlobalEvents);
+function $081cb5757e08788e$var$onTransitionEnd(e) {
+    let eventTarget = ($23f2114a1b82827e$export$e58f029f0fbfdb29)(e);
+    if (!$081cb5757e08788e$var$isTransitionEvent(e) || !eventTarget) return;
+    // Remove property from list of transitioning properties.
+    let properties = $081cb5757e08788e$var$transitionsByElement.get(eventTarget);
+    if (!properties) return;
+    properties.delete(e.propertyName);
+    // If empty, remove transitioncancel event, and remove the element from the list of transitioning elements.
+    if (properties.size === 0) {
+        eventTarget.removeEventListener('transitioncancel', $081cb5757e08788e$var$onTransitionEnd);
+        $081cb5757e08788e$var$transitionsByElement.delete(eventTarget);
+    }
+    // If no transitioning elements, call all of the queued callbacks.
+    if ($081cb5757e08788e$var$transitionsByElement.size === 0) for (let callback of $081cb5757e08788e$var$transitionCallbacks){
+        callback(true);
+        $081cb5757e08788e$var$transitionCallbacks.delete(callback);
+    }
+}
+function $081cb5757e08788e$var$setupGlobalEvents() {
+    ($d447af545b77c9f1$export$f531f92e2a15358f)(document, 'transitionrun', $081cb5757e08788e$var$onTransitionStart);
+    ($d447af545b77c9f1$export$f531f92e2a15358f)(document, 'transitionend', $081cb5757e08788e$var$onTransitionEnd);
 }
 /**
  * Cleans up any elements that are no longer in the document.
@@ -2884,15 +3059,23 @@ if (typeof document !== 'undefined') {
     // the explicit instanceof check, since it may be different in different contexts.
     if ('isConnected' in eventTarget && !eventTarget.isConnected) $081cb5757e08788e$var$transitionsByElement.delete(eventTarget);
 }
+if (typeof document !== 'undefined') {
+    if (document.readyState !== 'loading') $081cb5757e08788e$var$setupGlobalEvents();
+    else ($d447af545b77c9f1$export$f531f92e2a15358f)(document, 'DOMContentLoaded', $081cb5757e08788e$var$setupGlobalEvents);
+}
 function $081cb5757e08788e$export$24490316f764c430(fn) {
     // Wait one frame to see if an animation starts, e.g. a transition on mount.
-    requestAnimationFrame(()=>{
+    let frame = window.requestAnimationFrame(()=>{
         $081cb5757e08788e$var$cleanupDetachedElements();
         // If no transitions are running, call the function immediately.
         // Otherwise, add it to a list of callbacks to run at the end of the animation.
-        if ($081cb5757e08788e$var$transitionsByElement.size === 0) fn();
-        else $081cb5757e08788e$var$transitionCallbacks.add(fn);
+        if ($081cb5757e08788e$var$transitionsByElement.size === 0) return fn(false);
+        $081cb5757e08788e$var$transitionCallbacks.add(fn);
     });
+    return ()=>{
+        window.cancelAnimationFrame(frame);
+        $081cb5757e08788e$var$transitionCallbacks.delete(fn);
+    };
 }
 
 /*
@@ -3904,7 +4087,8 @@ const $8e9d2fae0ecb9001$var$globalAttrs = new Set([
     'lang',
     'hidden',
     'inert',
-    'translate'
+    'translate',
+    'suppressHydrationWarning'
 ]);
 const $8e9d2fae0ecb9001$var$globalEvents = new Set([
     'onClick',
@@ -4018,32 +4202,6 @@ function $cbf007e418543821$export$b0d6fa1ab32e3295(target) {
     }
 }
 
-/*
- * Copyright 2026 Adobe. All rights reserved.
- * This file is licensed to you under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License. You may obtain a copy
- * of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
- * OF ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- */ 
-function $7096878c21af5e66$export$a929f3f93e2cc67e(key, doc) {
-    let ownerWindow = ($d447af545b77c9f1$export$f21a1ffae260145a)(doc);
-    let ownerDocument = ($d447af545b77c9f1$export$b204af158042fbac)(doc);
-    if (ownerDocument == null || ownerWindow == null) return;
-    let content = undefined;
-    let selector = `meta[name="${CSS.escape(key)}"], meta[property="${CSS.escape(key)}"]`;
-    let meta = ownerDocument.querySelector(selector);
-    if (meta && meta instanceof ownerWindow.HTMLMetaElement) {
-        if (key === 'csp-nonce' && meta.nonce) content ??= meta.nonce || undefined;
-        if (meta.content) content ??= meta.content || undefined;
-    }
-    if (key === 'csp-nonce') content ??= ownerWindow.__webpack_nonce__ || globalThis.__webpack_nonce__ || undefined;
-    return content;
-}
-
 /*
  * Copyright 2026 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -5330,27 +5488,6 @@ try {
     }).resolvedOptions().signDisplay === 'exceptZero';
 // eslint-disable-next-line no-empty
 } catch  {}
-let $1dfb119a85e764e5$var$supportsUnit = false;
-try {
-    $1dfb119a85e764e5$var$supportsUnit = new Intl.NumberFormat('de-DE', {
-        style: 'unit',
-        unit: 'degree'
-    }).resolvedOptions().style === 'unit';
-// eslint-disable-next-line no-empty
-} catch  {}
-// Polyfill for units since Safari doesn't support them yet. See https://bugs.webkit.org/show_bug.cgi?id=215438.
-// Currently only polyfilling the unit degree in narrow format for ColorSlider in our supported locales.
-// Values were determined by switching to each locale manually in Chrome.
-const $1dfb119a85e764e5$var$UNITS = {
-    degree: {
-        narrow: {
-            default: "\xb0",
-            'ja-JP': " \u5EA6",
-            'zh-TW': "\u5EA6",
-            'sl-SI': " \xb0"
-        }
-    }
-};
 class $1dfb119a85e764e5$export$cc77c4ff7e8673c5 {
     constructor(locale, options = {}){
         this.numberFormatter = $1dfb119a85e764e5$var$getCachedNumberFormatter(locale, options);
@@ -5363,12 +5500,6 @@ class $1dfb119a85e764e5$export$cc77c4ff7e8673c5 {
         let res = '';
         if (!$1dfb119a85e764e5$var$supportsSignDisplay && this.options.signDisplay != null) res = $1dfb119a85e764e5$export$711b50b3c525e0f2(this.numberFormatter, this.options.signDisplay, value);
         else res = this.numberFormatter.format(value);
-        if (this.options.style === 'unit' && !$1dfb119a85e764e5$var$supportsUnit) {
-            let { unit: unit, unitDisplay: unitDisplay = 'short', locale: locale } = this.resolvedOptions();
-            if (!unit) return res;
-            let values = $1dfb119a85e764e5$var$UNITS[unit]?.[unitDisplay];
-            res += values[locale] || values.default;
-        }
         return res;
     }
     /** Formats a number to an array of parts such as separators, digits, punctuation, and more. */ formatToParts(value) {
@@ -5408,12 +5539,6 @@ class $1dfb119a85e764e5$export$cc77c4ff7e8673c5 {
             ...options,
             signDisplay: this.options.signDisplay
         };
-        if (!$1dfb119a85e764e5$var$supportsUnit && this.options.style === 'unit') options = {
-            ...options,
-            style: 'unit',
-            unit: this.options.unit,
-            unitDisplay: this.options.unitDisplay
-        };
         return options;
     }
 }
@@ -5423,15 +5548,6 @@ function $1dfb119a85e764e5$var$getCachedNumberFormatter(locale, options = {}) {
         if (!locale.includes('-u-')) locale += '-u-';
         locale += `-nu-${numberingSystem}`;
     }
-    if (options.style === 'unit' && !$1dfb119a85e764e5$var$supportsUnit) {
-        let { unit: unit, unitDisplay: unitDisplay = 'short' } = options;
-        if (!unit) throw new Error('unit option must be provided with style: "unit"');
-        if (!$1dfb119a85e764e5$var$UNITS[unit]?.[unitDisplay]) throw new Error(`Unsupported unit ${unit} with unitDisplay = ${unitDisplay}`);
-        options = {
-            ...options,
-            style: 'decimal'
-        };
-    }
     let cacheKey = locale + (options ? Object.entries(options).sort((a, b)=>a[0] < b[0] ? -1 : 1).join() : '');
     if ($1dfb119a85e764e5$var$formatterCache.has(cacheKey)) return $1dfb119a85e764e5$var$formatterCache.get(cacheKey);
     let numberFormatter = new Intl.NumberFormat(locale, options);
@@ -9798,11 +9914,14 @@ function $76d97191f0f90600$export$94ed1c92c7beeb22(node, checkForOverflow) {
  */ 
 
 function $51a3e22a5186a962$export$53a0910f038337bd(scrollView, element, opts = {}) {
-    let { block: block = 'nearest', inline: inline = 'nearest' } = opts;
     if (scrollView === element) return;
+    let target = element.getBoundingClientRect();
+    $51a3e22a5186a962$export$f064fd83a2c6e9ca(scrollView, element, target, opts);
+}
+function $51a3e22a5186a962$export$f064fd83a2c6e9ca(scrollView, element, target, opts = {}) {
+    let { block: block = 'nearest', inline: inline = 'nearest' } = opts;
     let y = scrollView.scrollTop;
     let x = scrollView.scrollLeft;
-    let target = element.getBoundingClientRect();
     let view = scrollView.getBoundingClientRect();
     let itemStyle = window.getComputedStyle(element);
     let viewStyle = window.getComputedStyle(scrollView);
@@ -19473,6 +19592,97 @@ function $77844860df94ba23$export$ea8f71083e90600f(props, ref) {
  */ 
 
 
+const $e0a0e4399f316b76$var$WEBKIT_OPEN_DELAY = 200;
+const $e0a0e4399f316b76$var$TRANSITION_FRAMETIME = 50;
+const $e0a0e4399f316b76$var$TRANSITION_TIMEOUT = 600;
+const $e0a0e4399f316b76$var$listenersByWindow = new WeakMap();
+const $e0a0e4399f316b76$var$transitionCallbacks = new Set();
+const $e0a0e4399f316b76$var$resizeCallbacks = new Set();
+function $e0a0e4399f316b76$var$onTransitionFrame(wasOpenKeyboard, signal) {
+    let isOpenKeyboard = ($bb39c0fc1c19b34c$export$b1f1c83775b8b5f7)();
+    // Flush resize callbacks when the keyboard has affected layout or we ran out of time.
+    if (wasOpenKeyboard !== isOpenKeyboard || signal.aborted) for (let callback of $e0a0e4399f316b76$var$resizeCallbacks){
+        callback(isOpenKeyboard);
+        $e0a0e4399f316b76$var$resizeCallbacks.delete(callback);
+    }
+    // WebKit only fires a single resize event at the start of an opening transition.
+    // The animation takes ~200ms, so restart the listener and flush when it runs out of time.
+    if (!wasOpenKeyboard && isOpenKeyboard && ($2add3ce32c6007eb$export$78551043582a6a98)() && !signal.aborted) {
+        window.clearInterval($e0a0e4399f316b76$var$listenersByWindow.get(window));
+        $e0a0e4399f316b76$var$listenersByWindow.set(window, $e0a0e4399f316b76$var$setupGlobalListeners($e0a0e4399f316b76$var$WEBKIT_OPEN_DELAY));
+        return;
+    }
+    // Flush transition callbacks when the animation has completed or we ran out of time.
+    if (wasOpenKeyboard !== isOpenKeyboard || signal.aborted) for (let callback of $e0a0e4399f316b76$var$transitionCallbacks){
+        callback(isOpenKeyboard);
+        $e0a0e4399f316b76$var$transitionCallbacks.delete(callback);
+    }
+    // Cancel the observer when no pending updates remain or we ran out of time.
+    if ($e0a0e4399f316b76$var$resizeCallbacks.size + $e0a0e4399f316b76$var$transitionCallbacks.size <= 0 || signal.aborted) {
+        window.clearInterval($e0a0e4399f316b76$var$listenersByWindow.get(window));
+        $e0a0e4399f316b76$var$listenersByWindow.delete(window);
+    }
+}
+function $e0a0e4399f316b76$var$setupGlobalListeners(timeout = $e0a0e4399f316b76$var$TRANSITION_TIMEOUT) {
+    return window.setInterval($e0a0e4399f316b76$var$onTransitionFrame, $e0a0e4399f316b76$var$TRANSITION_FRAMETIME, ($bb39c0fc1c19b34c$export$b1f1c83775b8b5f7)(), AbortSignal.timeout(timeout));
+}
+function $e0a0e4399f316b76$export$b80f73f72d03c10f(fn) {
+    // Flush synchronously when keyboard is unsupported. This is default for non-touch devices
+    // or devices which did not open their OSK within our opening timeout.
+    if (!($bb39c0fc1c19b34c$export$a986ed8aea890397)()) return fn(false), ()=>{};
+    // Wait two frames to see if focus lands on an input.
+    let frame = window.requestAnimationFrame(()=>{
+        frame = window.requestAnimationFrame(()=>{
+            let activeElement = document.hasFocus() ? ($23f2114a1b82827e$export$cd4e5573fbe2b576)() : null;
+            let willKeyboardOpen = ($bb39c0fc1c19b34c$export$c57958e35f31ed73)(activeElement);
+            // If keyboard won't change, call the function immediately.
+            if (($bb39c0fc1c19b34c$export$b1f1c83775b8b5f7)() === willKeyboardOpen) return fn(willKeyboardOpen);
+            // On close, fire immediately since consumers may assert the ICB.
+            if (($bb39c0fc1c19b34c$export$b1f1c83775b8b5f7)() && !willKeyboardOpen) return fn(willKeyboardOpen);
+            $e0a0e4399f316b76$var$resizeCallbacks.add(fn);
+            if (!$e0a0e4399f316b76$var$listenersByWindow.has(window)) $e0a0e4399f316b76$var$listenersByWindow.set(window, $e0a0e4399f316b76$var$setupGlobalListeners());
+        });
+    });
+    return ()=>{
+        window.cancelAnimationFrame(frame);
+        $e0a0e4399f316b76$var$resizeCallbacks.delete(fn);
+    };
+}
+function $e0a0e4399f316b76$export$c82b8fe1ad51fcd9(fn) {
+    // Flush synchronously when keyboard is unsupported. This is default for non-touch devices
+    // or devices which did not open their OSK within our opening timeout.
+    if (!($bb39c0fc1c19b34c$export$a986ed8aea890397)()) return fn(false), ()=>{};
+    // Wait two frames to see if focus lands on an input.
+    let frame = window.requestAnimationFrame(()=>{
+        frame = window.requestAnimationFrame(()=>{
+            let activeElement = document.hasFocus() ? ($23f2114a1b82827e$export$cd4e5573fbe2b576)() : null;
+            let willKeyboardOpen = ($bb39c0fc1c19b34c$export$c57958e35f31ed73)(activeElement);
+            // If keyboard won't transition, fire immediately.
+            if (($bb39c0fc1c19b34c$export$b1f1c83775b8b5f7)() === willKeyboardOpen) return fn(willKeyboardOpen);
+            $e0a0e4399f316b76$var$transitionCallbacks.add(fn);
+            if (!$e0a0e4399f316b76$var$listenersByWindow.has(window)) $e0a0e4399f316b76$var$listenersByWindow.set(window, $e0a0e4399f316b76$var$setupGlobalListeners());
+        });
+    });
+    return ()=>{
+        window.cancelAnimationFrame(frame);
+        $e0a0e4399f316b76$var$transitionCallbacks.delete(fn);
+    };
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+
 
 
 
@@ -19484,28 +19694,29 @@ const $0644e3663365bfe5$var$visualViewport = typeof document !== 'undefined' &&
 let $0644e3663365bfe5$var$preventScrollCount = 0;
 let $0644e3663365bfe5$var$restore;
 function $0644e3663365bfe5$export$ee0f7cc6afcd1c18(options = {}) {
-    let { isDisabled: isDisabled } = options;
+    let { isDisabled: isDisabled, UNSTABLE_overrideFocus: UNSTABLE_overrideFocus } = options;
     ($c4867b2f328c2698$export$e5c5a5f917a5871c)(()=>{
         if (isDisabled) return;
         $0644e3663365bfe5$var$preventScrollCount++;
         if ($0644e3663365bfe5$var$preventScrollCount === 1) {
             if (($2add3ce32c6007eb$export$fedb369cb70207f1)() && ($2add3ce32c6007eb$export$78551043582a6a98)()) $0644e3663365bfe5$var$restore = $0644e3663365bfe5$var$preventScrollMobileWebKit();
-            else $0644e3663365bfe5$var$restore = $0644e3663365bfe5$var$preventScrollStandard();
+            else $0644e3663365bfe5$var$restore = $0644e3663365bfe5$var$preventScrollStandard(UNSTABLE_overrideFocus);
         }
         return ()=>{
             $0644e3663365bfe5$var$preventScrollCount--;
             if ($0644e3663365bfe5$var$preventScrollCount === 0) $0644e3663365bfe5$var$restore();
         };
     }, [
-        isDisabled
+        isDisabled,
+        UNSTABLE_overrideFocus
     ]);
 }
 // For most browsers, all we need to do is set `overflow: hidden` on the root element, and
 // add some padding to prevent the page from shifting when the scrollbar is hidden.
-function $0644e3663365bfe5$var$preventScrollStandard() {
+function $0644e3663365bfe5$var$preventScrollStandard(UNSTABLE_overrideFocus) {
     let scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
     return ($a4e76a5424781910$export$e08e3b67e392101e)(scrollbarWidth > 0 && // Use scrollbar-gutter when supported because it also works for fixed positioned elements.
-    ('scrollbarGutter' in document.documentElement.style ? ($d447af545b77c9f1$export$37a5fde709c1db82)(document.documentElement, 'scrollbar-gutter', 'stable') : ($d447af545b77c9f1$export$37a5fde709c1db82)(document.documentElement, 'padding-right', `${scrollbarWidth}px`)), ($d447af545b77c9f1$export$37a5fde709c1db82)(document.documentElement, 'overflow', 'hidden'));
+    ('scrollbarGutter' in document.documentElement.style ? ($d447af545b77c9f1$export$37a5fde709c1db82)(document.documentElement, 'scrollbar-gutter', 'stable') : ($d447af545b77c9f1$export$37a5fde709c1db82)(document.documentElement, 'padding-right', `${scrollbarWidth}px`)), ($d447af545b77c9f1$export$37a5fde709c1db82)(document.documentElement, 'overflow', 'hidden'), UNSTABLE_overrideFocus && $0644e3663365bfe5$var$overrideFocus(), UNSTABLE_overrideFocus && ($bb39c0fc1c19b34c$export$a986ed8aea890397)() && $0644e3663365bfe5$var$handleBlur());
 }
 // Mobile Safari is a whole different beast. Even with overflow: hidden,
 // it still scrolls the page in many situations:
@@ -19536,7 +19747,7 @@ function $0644e3663365bfe5$var$preventScrollMobileWebKit() {
     let onTouchStart = (e)=>{
         // Store the nearest scrollable parent element from the element that the user touched.
         let target = ($23f2114a1b82827e$export$e58f029f0fbfdb29)(e);
-        scrollable = ($901761b40e390936$export$2bb74740c4e19def)(target) ? target : ($3578607fe3d4b096$export$cfa2225e87938781)(target, true);
+        scrollable = ($901761b40e390936$export$2bb74740c4e19def)(target, true) ? target : ($3578607fe3d4b096$export$cfa2225e87938781)(target, true);
         allowTouchMove = false;
         // If the target is selected, don't preventDefault in touchmove to allow user to adjust selection.
         let selection = target.ownerDocument.defaultView.getSelection();
@@ -19576,16 +19787,28 @@ function $0644e3663365bfe5$var$preventScrollMobileWebKit() {
         // because it must be set before the touchstart event.
         if (scrollable.scrollHeight === scrollable.clientHeight && scrollable.scrollWidth === scrollable.clientWidth) e.preventDefault();
     };
+    let restoreFocus = $0644e3663365bfe5$var$overrideFocus();
+    let removeEvents = ($a4e76a5424781910$export$e08e3b67e392101e)(($d447af545b77c9f1$export$f531f92e2a15358f)(document, 'touchstart', onTouchStart, {
+        passive: false,
+        capture: true
+    }), ($d447af545b77c9f1$export$f531f92e2a15358f)(document, 'touchmove', onTouchMove, {
+        passive: false,
+        capture: true
+    }), $0644e3663365bfe5$var$handleBlur());
+    return ()=>{
+        restoreOverflow();
+        removeEvents();
+        style.remove();
+        restoreFocus();
+    };
+}
+function $0644e3663365bfe5$var$handleBlur() {
     let onBlur = (e)=>{
         let target = ($23f2114a1b82827e$export$e58f029f0fbfdb29)(e);
         let relatedTarget = e.relatedTarget;
-        if (relatedTarget && ($bb39c0fc1c19b34c$export$c57958e35f31ed73)(relatedTarget)) {
-            // Focus without scrolling the whole page, and then scroll into view manually.
-            relatedTarget.focus({
-                preventScroll: true
-            });
-            $0644e3663365bfe5$var$scrollIntoViewWhenReady(relatedTarget, ($bb39c0fc1c19b34c$export$c57958e35f31ed73)(target));
-        } else if (!relatedTarget) {
+        if (relatedTarget && ($bb39c0fc1c19b34c$export$c57958e35f31ed73)(relatedTarget)) // Re-focus programmatically to have the override below perform the scroll.
+        relatedTarget.focus();
+        else if (!relatedTarget) {
             // When tapping the Done button on the keyboard, focus moves to the body.
             // FocusScope will then restore focus back to the input. Later when tapping
             // the same input again, it is already focused, so no blur event will fire,
@@ -19597,34 +19820,30 @@ function $0644e3663365bfe5$var$preventScrollMobileWebKit() {
             });
         }
     };
+    return ($d447af545b77c9f1$export$f531f92e2a15358f)(document, 'blur', onBlur, true);
+}
+function $0644e3663365bfe5$var$overrideFocus() {
     // Override programmatic focus to scroll into view without scrolling the whole page.
     let focus = HTMLElement.prototype.focus;
     Reflect.defineProperty(HTMLElement.prototype, 'focus', {
         configurable: true,
         writable: true,
         value: function(opts) {
-            // Track whether the keyboard was already visible before.
-            let activeElement = ($23f2114a1b82827e$export$cd4e5573fbe2b576)();
-            let wasKeyboardVisible = activeElement != null && ($bb39c0fc1c19b34c$export$c57958e35f31ed73)(activeElement);
             // Focus the element without scrolling the page.
             focus.call(this, {
                 ...opts,
                 preventScroll: true
             });
-            if (!opts || !opts.preventScroll) $0644e3663365bfe5$var$scrollIntoViewWhenReady(this, wasKeyboardVisible);
+            if (!opts || !opts.preventScroll) {
+                let scroll = ()=>{
+                    let activeElement = ($23f2114a1b82827e$export$cd4e5573fbe2b576)();
+                    if (activeElement === this) $0644e3663365bfe5$var$scrollIntoView(this);
+                };
+                ($e0a0e4399f316b76$export$b80f73f72d03c10f)((isOpen)=>isOpen ? scroll() : ($e0a0e4399f316b76$export$c82b8fe1ad51fcd9)(()=>scroll()));
+            }
         }
     });
-    let removeEvents = ($a4e76a5424781910$export$e08e3b67e392101e)(($d447af545b77c9f1$export$f531f92e2a15358f)(document, 'touchstart', onTouchStart, {
-        passive: false,
-        capture: true
-    }), ($d447af545b77c9f1$export$f531f92e2a15358f)(document, 'touchmove', onTouchMove, {
-        passive: false,
-        capture: true
-    }), ($d447af545b77c9f1$export$f531f92e2a15358f)(document, 'blur', onBlur, true));
     return ()=>{
-        restoreOverflow();
-        removeEvents();
-        style.remove();
         Reflect.defineProperty(HTMLElement.prototype, 'focus', {
             configurable: true,
             writable: true,
@@ -19632,19 +19851,10 @@ function $0644e3663365bfe5$var$preventScrollMobileWebKit() {
         });
     };
 }
-function $0644e3663365bfe5$var$scrollIntoViewWhenReady(target, wasKeyboardVisible) {
-    if (wasKeyboardVisible || !$0644e3663365bfe5$var$visualViewport) // If the keyboard was already visible, scroll the target into view immediately.
-    $0644e3663365bfe5$var$scrollIntoView(target);
-    else // Otherwise, wait for the visual viewport to resize before scrolling so we can
-    // measure the correct position to scroll to.
-    $0644e3663365bfe5$var$visualViewport.addEventListener('resize', ()=>$0644e3663365bfe5$var$scrollIntoView(target), {
-        once: true
-    });
-}
 function $0644e3663365bfe5$var$scrollIntoView(target) {
     let root = document.scrollingElement || document.documentElement;
     let nextTarget = target;
-    while(nextTarget && nextTarget !== root){
+    while(nextTarget && nextTarget !== root && nextTarget.isConnected){
         // Find the parent scrollable element and adjust the scroll position if the target is not already in view.
         let scrollable = ($3578607fe3d4b096$export$cfa2225e87938781)(nextTarget);
         if (scrollable !== document.documentElement && scrollable !== document.body && scrollable !== nextTarget) {
@@ -20181,9 +20391,21 @@ function $f11fb0bcf1b2687a$export$61c6a8c84e605fb6(props) {
  */ 
 
 
-function $fcc7165e876206c6$export$6d3443f2c48bfc20(ref, isReady = true) {
+
+
+
+function $fcc7165e876206c6$export$6d3443f2c48bfc20(ref, isReady = true, onEnter) {
     let [isEntering, setEntering] = (useState)(true);
     let isAnimationReady = isEntering && isReady;
+    // Hide the element while it prepares for entry, using only non-layout-thrashing attributes.
+    // This prevents accidental flashes of content in scenarios where no hidden styling is applied
+    // while the enter animation is not yet ready (e.g. popovers prior to placement calculation).
+    ($c4867b2f328c2698$export$e5c5a5f917a5871c)(()=>{
+        if (!isReady && ref.current) return ($a4e76a5424781910$export$e08e3b67e392101e)(($d447af545b77c9f1$export$37a5fde709c1db82)(ref.current, 'opacity', '0'), ($d447af545b77c9f1$export$37a5fde709c1db82)(ref.current, 'clip', 'rect(0 0 0 0)'), ($d447af545b77c9f1$export$37a5fde709c1db82)(ref.current, 'clip-path', 'inset(50%)'), ($d447af545b77c9f1$export$37a5fde709c1db82)(ref.current, 'mask-image', 'linear-gradient(#0000, #0000)'));
+    }, [
+        ref,
+        isReady
+    ]);
     // There are two cases for entry animations:
     // 1. CSS @keyframes. The `animation` property is set during the isEntering state, and it is removed after the animation finishes.
     // 2. CSS transitions. The initial styles are applied during the isEntering state, and removed immediately, causing the transition to occur.
@@ -20198,10 +20420,10 @@ function $fcc7165e876206c6$export$6d3443f2c48bfc20(ref, isReady = true) {
         ref,
         isAnimationReady
     ]);
-    $fcc7165e876206c6$var$useAnimation(ref, isAnimationReady, (useCallback)(()=>setEntering(false), []));
+    $fcc7165e876206c6$var$useAnimation(ref, isAnimationReady, onEnter, (useCallback)(()=>setEntering(false), []));
     return isAnimationReady;
 }
-function $fcc7165e876206c6$export$45fda7c47f93fd48(ref, isOpen) {
+function $fcc7165e876206c6$export$45fda7c47f93fd48(ref, isOpen, onExit) {
     let [exitState, setExitState] = (useState)(isOpen ? 'open' : 'closed');
     switch(exitState){
         case 'open':
@@ -20216,35 +20438,39 @@ function $fcc7165e876206c6$export$45fda7c47f93fd48(ref, isOpen) {
             break;
     }
     let isExiting = exitState === 'exiting';
-    $fcc7165e876206c6$var$useAnimation(ref, isExiting, (useCallback)(()=>{
+    $fcc7165e876206c6$var$useAnimation(ref, isExiting, onExit, (useCallback)(()=>{
         // Set the state to closed, which will cause the element to be unmounted.
         setExitState((state)=>state === 'exiting' ? 'closed' : state);
     }, []));
     return isExiting;
 }
-function $fcc7165e876206c6$var$useAnimation(ref, isActive, onEnd) {
+function $fcc7165e876206c6$var$useAnimation(ref, isActive, onStart, onEnd) {
+    let isActiveRef = (useRef)(null);
+    let start = ($fe16bffc7a557bf0$export$7f54fc3180508a52)(onStart);
     ($c4867b2f328c2698$export$e5c5a5f917a5871c)(()=>{
-        if (isActive && ref.current) {
+        if (isActive && ref.current && isActiveRef.current !== isActive) {
+            isActiveRef.current = isActive;
             if (!('getAnimations' in ref.current)) {
                 // JSDOM
                 onEnd();
                 return;
             }
-            let animations = ref.current.getAnimations();
-            if (animations.length === 0) {
+            let startPromise = start?.(ref.current);
+            let animations = ref.current.getAnimations().filter((a)=>(typeof DocumentTimeline === 'undefined' || a.timeline instanceof DocumentTimeline) && a.playState === 'running');
+            if (animations.length === 0 && !startPromise) {
                 onEnd();
                 return;
             }
-            let canceled = false;
-            Promise.allSettled(animations.map((a)=>a.finished)).then(()=>{
-                if (!canceled) (flushSync)(()=>{
+            Promise.all([
+                startPromise,
+                ...animations.map((a)=>a.finished)
+            ]).then(()=>{
+                (flushSync)(()=>{
                     onEnd();
                 });
-            });
-            return ()=>{
-                canceled = true;
-            };
+            }).catch(()=>{});
         }
+        isActiveRef.current = isActive;
     }, [
         ref,
         isActive,
@@ -20279,6 +20505,7 @@ function $fcc7165e876206c6$var$useAnimation(ref, isActive, onEnd) {
 
 
 
+
 const $542a13ca2fa5b484$export$9b9a0cd73afb7ca4 = /*#__PURE__*/ (createContext)(null);
 // Stores a ref for the portal container for a group of popovers (e.g. submenus).
 const $542a13ca2fa5b484$var$PopoverGroupContext = /*#__PURE__*/ (createContext)(null);
@@ -20322,6 +20549,7 @@ function $542a13ca2fa5b484$var$PopoverInner({ state: state, isExiting: isExiting
     let containerRef = (useRef)(null);
     let groupCtx = (useContext)($542a13ca2fa5b484$var$PopoverGroupContext);
     let isSubPopover = groupCtx && props.trigger === 'SubmenuTrigger';
+    let [isOpen, setIsOpen] = (useState)(false);
     let { popoverProps: popoverProps, underlayProps: underlayProps, arrowProps: arrowProps, placement: placement, triggerAnchorPoint: triggerAnchorPoint } = ($f8a024fbad3a5a2e$export$542a6fd13ac93354)({
         ...props,
         offset: props.offset ?? 8,
@@ -20333,7 +20561,7 @@ function $542a13ca2fa5b484$var$PopoverInner({ state: state, isExiting: isExiting
     let ref = props.popoverRef;
     // Skip the automatic entry animation when opening instantly (e.g. swapping between previews
     // during warmup). An explicitly provided isEntering prop still takes precedence.
-    let enterAnimation = ($fcc7165e876206c6$export$6d3443f2c48bfc20)(ref, !!placement);
+    let enterAnimation = ($fcc7165e876206c6$export$6d3443f2c48bfc20)(ref, !!placement && isOpen);
     // oxlint-disable-next-line react/react-compiler
     let isEntering = props.isEntering || !props.shouldSkipAnimation && enterAnimation || false;
     // oxlint-disable-next-line react/react-compiler
@@ -20376,7 +20604,10 @@ function $542a13ca2fa5b484$var$PopoverInner({ state: state, isExiting: isExiting
     // oxlint-enable react/react-compiler
     let children = (useMemo)(()=>{
         let children = renderProps.children;
-        if (clearContexts) for (let Context of clearContexts)children = /*#__PURE__*/ ($8WNJc$react).createElement(Context.Provider, {
+        for (let Context of [
+            $542a13ca2fa5b484$export$9b9a0cd73afb7ca4,
+            ...clearContexts ?? []
+        ])children = /*#__PURE__*/ ($8WNJc$react).createElement(Context.Provider, {
             value: null
         }, children);
         return children;
@@ -20406,6 +20637,8 @@ function $542a13ca2fa5b484$var$PopoverInner({ state: state, isExiting: isExiting
         ...renderProps.style,
         '--trigger-width': renderProps.style?.['--trigger-width'] || triggerWidth
     };
+    // Since our trigger may open the OSK, we defer the reveal, as a courtesy, to avoid layout shift.
+    ($c4867b2f328c2698$export$e5c5a5f917a5871c)(()=>($e0a0e4399f316b76$export$b80f73f72d03c10f)(()=>setIsOpen(true)), []);
     // oxlint-disable react/react-compiler
     let overlay = /*#__PURE__*/ ($8WNJc$react).createElement(($7230ffa83bc0c2cf$export$df3a06d6289f983e).div, {
         ...($bbaa08b3cd72f041$export$9d1611c77c2fe928)(($8e9d2fae0ecb9001$export$457c3d6518dd4c6f)(props, {
@@ -22384,15 +22617,15 @@ const $49319ee1285aa241$export$2ce376c2cc3355c8 = /*#__PURE__*/ ($42ceafc619f9c3
 
 
 function $13150e6629d46e45$export$d55e7ee900f34e93(props, ref) {
-    let { role: role = 'dialog' } = props;
+    let { role: role = 'dialog', isEntering: isEntering } = props;
     let titleId = ($390e54f620492c70$export$b4cc09c592e8fdb8)();
     titleId = props['aria-label'] ? undefined : titleId;
     let contentId = ($390e54f620492c70$export$b4cc09c592e8fdb8)();
     contentId = role === 'alertdialog' && !props['aria-describedby'] ? contentId : undefined;
     let isRefocusing = (useRef)(false);
-    // Focus the dialog itself on mount, unless a child element is already focused.
+    // Focus the dialog itself on mount (or once it has entered), unless a child element is already focused.
     (useEffect)(()=>{
-        if (ref.current && !($23f2114a1b82827e$export$b4f377a2b6254582)(ref.current)) {
+        if (!isEntering && ref.current && !($23f2114a1b82827e$export$b4f377a2b6254582)(ref.current)) {
             ($f192c2f16961cbe0$export$80f3e147d781571c)(ref.current);
             // Safari on iOS does not move the VoiceOver cursor to the dialog
             // or announce that it has opened until it has rendered. A workaround
@@ -22413,7 +22646,8 @@ function $13150e6629d46e45$export$d55e7ee900f34e93(props, ref) {
             };
         }
     }, [
-        ref
+        ref,
+        isEntering
     ]);
     ($d7a937236970dc7f$export$14c98a7594375490)();
     // Warn in dev mode if the dialog has no accessible title.
@@ -24031,7 +24265,9 @@ function $d51706f903be7eab$export$1315d136e6f7581(segment, state, ref) {
                 era: era
             }).toDate('UTC');
             let parts = eraFormatter.formatToParts(eraDate);
-            let formatted = parts.find((p)=>p.type === 'era').value;
+            // Some eras have no localized name in CLDR (e.g. the Coptic 'BCE' era), in which case
+            // Intl omits the era part entirely. Fall back to the era identifier so it stays typeable.
+            let formatted = parts.find((p)=>p.type === 'era')?.value ?? era;
             return {
                 era: era,
                 formatted: formatted
@@ -28245,17 +28481,24 @@ function $5698867baeb53f4e$export$dbc0f175b25fb0fb(props, state, ref) {
         onClose: state.close
     }, ref);
     ($0644e3663365bfe5$export$ee0f7cc6afcd1c18)({
-        isDisabled: !state.isOpen
+        isDisabled: !state.isOpen,
+        UNSTABLE_overrideFocus: props.UNSTABLE_overrideFocus
     });
     ($d7a937236970dc7f$export$14c98a7594375490)();
+    let { isEntering: isEntering } = props;
     (useEffect)(()=>{
-        if (state.isOpen && ref.current) return ($58196c8d6a1f38fc$export$1c3ebcada18427bf)([
-            ref.current
-        ], {
-            shouldUseInert: true
-        });
+        if (state.isOpen && ref.current) {
+            if (isEntering) // Prevent a parent modal from hiding this one while it is entering.
+            return ($58196c8d6a1f38fc$export$1020fa7f77e17884)(ref.current);
+            return ($58196c8d6a1f38fc$export$1c3ebcada18427bf)([
+                ref.current
+            ], {
+                shouldUseInert: true
+            });
+        }
     }, [
         state.isOpen,
+        isEntering,
         ref
     ]);
     return {
@@ -28279,9 +28522,11 @@ function $5698867baeb53f4e$export$dbc0f175b25fb0fb(props, state, ref) {
 
 
 
+
 let $6066a2c586ade9e1$var$visualViewport = typeof document !== 'undefined' && window.visualViewport;
 function $6066a2c586ade9e1$export$d699905dd57c73ca() {
     let isSSR = ($c7eafbbe1ea5834e$export$535bd6ca7f90a273)();
+    let unmountRef = (useRef)(null);
     let [size, setSize] = (useState)(()=>isSSR ? {
             width: 0,
             height: 0
@@ -28301,13 +28546,12 @@ function $6066a2c586ade9e1$export$d699905dd57c73ca() {
         };
         // When closing the keyboard, WebKit on iOS does not fire the visual viewport resize event until the animation is complete.
         // We can anticipate this and resize early by handling the blur event and using the layout size.
-        let frame;
         let onBlur = (e)=>{
             if ($6066a2c586ade9e1$var$visualViewport && $6066a2c586ade9e1$var$visualViewport.scale > 1) return;
-            if (($bb39c0fc1c19b34c$export$c57958e35f31ed73)(($23f2114a1b82827e$export$e58f029f0fbfdb29)(e))) // Wait one frame to see if a new element gets focused.
-            frame = requestAnimationFrame(()=>{
-                let activeElement = ($23f2114a1b82827e$export$cd4e5573fbe2b576)();
-                if (!activeElement || !($bb39c0fc1c19b34c$export$c57958e35f31ed73)(activeElement)) updateSize({
+            if (!($bb39c0fc1c19b34c$export$c57958e35f31ed73)(($23f2114a1b82827e$export$e58f029f0fbfdb29)(e))) return;
+            unmountRef.current = ($e0a0e4399f316b76$export$b80f73f72d03c10f)((isOpen)=>{
+                if (isOpen) return;
+                updateSize({
                     width: document.documentElement.clientWidth,
                     height: document.documentElement.clientHeight
                 });
@@ -28318,7 +28562,7 @@ function $6066a2c586ade9e1$export$d699905dd57c73ca() {
         if (!$6066a2c586ade9e1$var$visualViewport) window.addEventListener('resize', onResize);
         else $6066a2c586ade9e1$var$visualViewport.addEventListener('resize', onResize);
         return ()=>{
-            cancelAnimationFrame(frame);
+            unmountRef.current?.();
             if (($2add3ce32c6007eb$export$fedb369cb70207f1)() && ($2add3ce32c6007eb$export$78551043582a6a98)()) window.removeEventListener('blur', onBlur, true);
             if (!$6066a2c586ade9e1$var$visualViewport) window.removeEventListener('resize', onResize);
             else $6066a2c586ade9e1$var$visualViewport.removeEventListener('resize', onResize);
@@ -28362,10 +28606,12 @@ function $6066a2c586ade9e1$export$d699905dd57c73ca() {
 
 
 
+
+
 const $8b8d26808cb8cb53$export$ab57792b9b6974a6 = /*#__PURE__*/ (createContext)(null);
-const $8b8d26808cb8cb53$var$InternalModalContext = /*#__PURE__*/ (createContext)(null);
+const $8b8d26808cb8cb53$export$6bc057cefccad9c8 = /*#__PURE__*/ (createContext)(null);
 const $8b8d26808cb8cb53$export$2b77a92f1a5ad772 = /*#__PURE__*/ (forwardRef)(function Modal(props, ref) {
-    let ctx = (useContext)($8b8d26808cb8cb53$var$InternalModalContext);
+    let ctx = (useContext)($8b8d26808cb8cb53$export$6bc057cefccad9c8);
     if (ctx) {
         if (process.env.NODE_ENV !== 'production' && (props.onOpenChange || props.defaultOpen !== undefined || props.isOpen !== undefined)) {
             // create a list of props that are passed in but not allowed when using an external ModalOverlay
@@ -28414,8 +28660,9 @@ function $8b8d26808cb8cb53$var$ModalOverlayWithForwardRef(props, ref) {
     }
     let objectRef = ($03e8ab2d84d7657a$export$4338b53315abf666)(ref);
     let modalRef = (useRef)(null);
-    let isOverlayExiting = ($fcc7165e876206c6$export$45fda7c47f93fd48)(objectRef, state.isOpen);
-    let isModalExiting = ($fcc7165e876206c6$export$45fda7c47f93fd48)(modalRef, state.isOpen);
+    let isOverlayExiting = ($fcc7165e876206c6$export$45fda7c47f93fd48)(objectRef, state.isOpen, props.onExit);
+    let onExitRef = (useRef)(null);
+    let isModalExiting = ($fcc7165e876206c6$export$45fda7c47f93fd48)(modalRef, state.isOpen, (element)=>onExitRef.current?.(element));
     let isExiting = isOverlayExiting || isModalExiting || props.isExiting || false;
     let isSSR = ($c7eafbbe1ea5834e$export$535bd6ca7f90a273)();
     if (!state.isOpen && !isExiting || isSSR) return null;
@@ -28424,15 +28671,26 @@ function $8b8d26808cb8cb53$var$ModalOverlayWithForwardRef(props, ref) {
         state: state,
         isExiting: isExiting,
         overlayRef: objectRef,
-        modalRef: modalRef
+        modalRef: modalRef,
+        onExitRef: onExitRef
     });
 }
 const $8b8d26808cb8cb53$export$8948f78d83984c69 = /*#__PURE__*/ (forwardRef)($8b8d26808cb8cb53$var$ModalOverlayWithForwardRef);
-function $8b8d26808cb8cb53$var$ModalOverlayInner({ UNSTABLE_portalContainer: UNSTABLE_portalContainer, ...props }) {
+function $8b8d26808cb8cb53$var$ModalOverlayInner({ UNSTABLE_portalContainer: UNSTABLE_portalContainer, UNSTABLE_deferUntilEntered: UNSTABLE_deferUntilEntered, ...props }) {
     let modalRef = props.modalRef;
     let { state: state } = props;
-    let { modalProps: modalProps, underlayProps: underlayProps } = ($5698867baeb53f4e$export$dbc0f175b25fb0fb)(props, state, modalRef);
-    let entering = ($fcc7165e876206c6$export$6d3443f2c48bfc20)(props.overlayRef) || props.isEntering || false;
+    let [isOpen, setIsOpen] = (useState)(false);
+    let entering = ($fcc7165e876206c6$export$6d3443f2c48bfc20)(props.overlayRef, isOpen, props.onEnter) || props.isEntering || false;
+    let isDeferred = !!UNSTABLE_deferUntilEntered && (!isOpen || entering);
+    let { modalProps: modalProps, underlayProps: underlayProps } = ($5698867baeb53f4e$export$dbc0f175b25fb0fb)({
+        ...props,
+        isEntering: isDeferred
+    }, state, modalRef);
+    // Pass the entering state to the dialog so it waits to move focus until the modal has entered.
+    let dialogContext = (useContext)(($f2ff30fde7b014be$export$8b93a07348a7730c));
+    let mergedDialogContext = UNSTABLE_deferUntilEntered ? $8b8d26808cb8cb53$var$mergeDialogContext(dialogContext, {
+        isEntering: isDeferred
+    }) : dialogContext;
     let renderProps = ($7230ffa83bc0c2cf$export$4d86445c2cf5e3)({
         ...props,
         defaultClassName: 'react-aria-ModalOverlay',
@@ -28460,6 +28718,8 @@ function $8b8d26808cb8cb53$var$ModalOverlayInner({ UNSTABLE_portalContainer: UNS
         '--page-width': pageWidth !== undefined ? pageWidth + 'px' : undefined,
         '--page-height': pageHeight !== undefined ? pageHeight + 'px' : undefined
     };
+    // Since an auto-focused input may open the OSK, we defer the reveal, as a courtesy, to avoid layout shift.
+    ($c4867b2f328c2698$export$e5c5a5f917a5871c)(()=>($e0a0e4399f316b76$export$b80f73f72d03c10f)(()=>setIsOpen(true)), []);
     // oxlint-disable react/react-compiler
     return /*#__PURE__*/ ($8WNJc$react).createElement(($d7a937236970dc7f$export$c6fdb837b070b4ff), {
         isExiting: props.isExiting,
@@ -28476,31 +28736,54 @@ function $8b8d26808cb8cb53$var$ModalOverlayInner({ UNSTABLE_portalContainer: UNS
     }, /*#__PURE__*/ ($8WNJc$react).createElement(($7230ffa83bc0c2cf$export$2881499e37b75b9a), {
         values: [
             [
-                $8b8d26808cb8cb53$var$InternalModalContext,
+                $8b8d26808cb8cb53$export$6bc057cefccad9c8,
                 {
                     modalProps: modalProps,
                     modalRef: modalRef,
                     isExiting: props.isExiting,
+                    onExitRef: props.onExitRef,
+                    isOpen: isOpen,
                     isDismissable: props.isDismissable
                 }
             ],
             [
                 ($f2ff30fde7b014be$export$d2f961adcb0afbe),
                 state
+            ],
+            [
+                ($f2ff30fde7b014be$export$8b93a07348a7730c),
+                mergedDialogContext
             ]
         ]
     }, renderProps.children)));
 // oxlint-enable react/react-compiler
 }
+function $8b8d26808cb8cb53$var$mergeDialogContext(context, props) {
+    if (context && 'slots' in context && context.slots) {
+        let slots = {};
+        for(let key in context.slots)slots[key] = {
+            ...context.slots[key],
+            ...props
+        };
+        return {
+            ...context,
+            slots: slots
+        };
+    }
+    return {
+        ...context,
+        ...props
+    };
+}
 function $8b8d26808cb8cb53$var$ModalContent(props) {
-    let { modalProps: modalProps, modalRef: modalRef, isExiting: isExiting, isDismissable: isDismissable } = (useContext)($8b8d26808cb8cb53$var$InternalModalContext);
+    let { modalProps: modalProps, modalRef: modalRef, isExiting: isExiting, onExitRef: onExitRef, isDismissable: isDismissable, isOpen: isOpen } = (useContext)($8b8d26808cb8cb53$export$6bc057cefccad9c8);
     let state = (useContext)(($f2ff30fde7b014be$export$d2f961adcb0afbe));
     let mergedRefs = (useMemo)(()=>($4064df0d6f9620e1$export$c9058316764c140e)(props.modalRef, modalRef), [
         props.modalRef,
         modalRef
     ]);
     let ref = ($03e8ab2d84d7657a$export$4338b53315abf666)(mergedRefs);
-    let entering = ($fcc7165e876206c6$export$6d3443f2c48bfc20)(ref);
+    let entering = ($fcc7165e876206c6$export$6d3443f2c48bfc20)(ref, isOpen, props.onEnter);
     let renderProps = ($7230ffa83bc0c2cf$export$4d86445c2cf5e3)({
         ...props,
         defaultClassName: 'react-aria-Modal',
@@ -28510,6 +28793,9 @@ function $8b8d26808cb8cb53$var$ModalContent(props) {
             state: state
         }
     });
+    ($c4867b2f328c2698$export$e5c5a5f917a5871c)(()=>{
+        if (onExitRef) onExitRef.current = props.onExit;
+    });
     return /*#__PURE__*/ ($8WNJc$react).createElement(($7230ffa83bc0c2cf$export$df3a06d6289f983e).div, {
         ...($bbaa08b3cd72f041$export$9d1611c77c2fe928)(($8e9d2fae0ecb9001$export$457c3d6518dd4c6f)(props, {
             global: true
@@ -29341,6 +29627,7 @@ function $b046d185a4525d56$export$f809e80f58e251d1(props, state, triggerRef) {
         focus: ()=>triggerRef.current?.focus()
     }, state, props.selectRef);
     let setValue = state.setValue;
+    // Used for both onChange and onInput, so accept the common supertype of both event types.
     let onChange = (useCallback)((e)=>{
         let eventTarget = ($23f2114a1b82827e$export$e58f029f0fbfdb29)(e);
         if (eventTarget.multiple) setValue(Array.from(eventTarget.selectedOptions, (option)=>option.value));