@ionic/core 9.0.11-dev.11793890855.1bf6a6e5 → 9.0.11-dev.11793906456.1ea7a0a7

package/dist/esm/{overlays-C8sf7PId.js → overlays-BBgMM61s.js}

@@ -1,13 +1,160 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { d as doc } from './index-ZjP4CjeZ.js';
-import { p as focusRedirectedElement, c as componentOnReady, g as getElementRoot, f as addEventListener, m as removeEventListener, q as focusVisibleElement } from './helpers-B_F2b1gy.js';
-import { c as getIonTheme, b as getIonMode, O as OVERLAY_BACK_BUTTON_PRIORITY, s as shouldUseCloseWatcher, u as updateCloseWatcher, d as addCloseWatcherCondition } from './ionic-global-DSbFWXp3.js';
-import { i as config, c as printIonError, a as printIonWarning } from './index-hR6kxzTq.js';
-import { C as CoreDelegate } from './framework-delegate-99Ms_INy.js';
+import { w as win, p as focusVisibleElement, c as componentOnReady, g as getElementRoot, n as doc, f as addEventListener, m as removeEventListener } from './helpers-p94IkmEA.js';
+import { i as config, c as printIonError, a as printIonWarning } from './index-BpRUsN_W.js';
+import { b as getIonMode } from './ionic-global-Cep6oYzK.js';
+import { C as CoreDelegate } from './framework-delegate-CW5_kWfc.js';
 import { B as BACKDROP_NO_SCROLL } from './gesture-controller-B_gJaBk0.js';
 
+/**
+ * CloseWatcher is a newer API that lets
+ * use detect the hardware back button event
+ * in a web browser: https://caniuse.com/?search=closewatcher
+ * However, not every browser supports it yet.
+ *
+ * This needs to be a function so that we can
+ * check the config once it has been set.
+ * Otherwise, this code would be evaluated the
+ * moment this file is evaluated which could be
+ * before the config is set.
+ */
+const shouldUseCloseWatcher = () => config.get('experimentalCloseWatcher', false) && win !== undefined && 'CloseWatcher' in win;
+/**
+ * When hardwareBackButton: false in config,
+ * we need to make sure we also block the default
+ * webview behavior. If we don't then it will be
+ * possible for users to navigate backward while
+ * an overlay is still open. Additionally, it will
+ * give the appearance that the hardwareBackButton
+ * config is not working as the page transition
+ * will still happen.
+ */
+const blockHardwareBackButton = () => {
+    document.addEventListener('backbutton', () => { });
+};
+const closeWatcherConditions = [];
+let syncCloseWatcher;
+/**
+ * Registers a check for whether the back button
+ * has something to close. The CloseWatcher is only
+ * active while one of these checks passes.
+ */
+const addCloseWatcherCondition = (condition) => {
+    closeWatcherConditions.push(condition);
+};
+/**
+ * Call this whenever something the back button
+ * can close opens or closes.
+ */
+const updateCloseWatcher = () => {
+    syncCloseWatcher?.();
+};
+const startHardwareBackButton = () => {
+    const doc = document;
+    let busy = false;
+    const backButtonCallback = () => {
+        if (busy) {
+            return;
+        }
+        let index = 0;
+        let handlers = [];
+        const ev = new CustomEvent('ionBackButton', {
+            bubbles: false,
+            detail: {
+                register(priority, handler) {
+                    handlers.push({ priority, handler, id: index++ });
+                },
+            },
+        });
+        doc.dispatchEvent(ev);
+        const executeAction = async (handlerRegister) => {
+            try {
+                if (handlerRegister?.handler) {
+                    const result = handlerRegister.handler(processHandlers);
+                    if (result != null) {
+                        await result;
+                    }
+                }
+            }
+            catch (e) {
+                printIonError('[ion-app] - Exception in startHardwareBackButton:', e);
+            }
+        };
+        const processHandlers = () => {
+            if (handlers.length > 0) {
+                let selectedHandler = {
+                    priority: Number.MIN_SAFE_INTEGER,
+                    handler: () => undefined,
+                    id: -1,
+                };
+                handlers.forEach((handler) => {
+                    if (handler.priority >= selectedHandler.priority) {
+                        selectedHandler = handler;
+                    }
+                });
+                busy = true;
+                handlers = handlers.filter((handler) => handler.id !== selectedHandler.id);
+                executeAction(selectedHandler).then(() => (busy = false));
+            }
+        };
+        processHandlers();
+    };
+    /**
+     * Android WebView never sends the hardware back
+     * button to a CloseWatcher, so hybrid apps still
+     * need this. Browsers never fire backbutton.
+     */
+    doc.addEventListener('backbutton', backButtonCallback);
+    if (shouldUseCloseWatcher()) {
+        let watcher;
+        /**
+         * An active CloseWatcher stops the back button from
+         * navigating, so only keep one while there's something to close.
+         */
+        syncCloseWatcher = () => {
+            const canClose = closeWatcherConditions.some((condition) => condition());
+            if (!canClose) {
+                watcher?.destroy();
+                watcher = undefined;
+                return;
+            }
+            if (watcher !== undefined) {
+                return;
+            }
+            watcher = new win.CloseWatcher();
+            /**
+             * Once a close request happens
+             * the watcher gets destroyed.
+             * As a result, we need to re-configure
+             * the watcher so we can respond to other
+             * close requests, including after one that
+             * closed nothing, like a modal whose canDismiss
+             * returned false.
+             */
+            watcher.onclose = () => {
+                watcher = undefined;
+                backButtonCallback();
+                syncCloseWatcher?.();
+            };
+        };
+        syncCloseWatcher();
+    }
+};
+const OVERLAY_BACK_BUTTON_PRIORITY = 100;
+const MENU_BACK_BUTTON_PRIORITY = 99; // 1 less than overlay priority since menu is displayed behind overlays
+
+var hardwareBackButton = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MENU_BACK_BUTTON_PRIORITY: MENU_BACK_BUTTON_PRIORITY,
+    OVERLAY_BACK_BUTTON_PRIORITY: OVERLAY_BACK_BUTTON_PRIORITY,
+    addCloseWatcherCondition: addCloseWatcherCondition,
+    blockHardwareBackButton: blockHardwareBackButton,
+    shouldUseCloseWatcher: shouldUseCloseWatcher,
+    startHardwareBackButton: startHardwareBackButton,
+    updateCloseWatcher: updateCloseWatcher
+});
+
 /**
  * This query string selects elements that
  * are eligible to receive focus. We select
@@ -20,7 +167,7 @@ import { B as BACKDROP_NO_SCROLL } from './gesture-controller-B_gJaBk0.js';
  * Note: We need this distinction because `disabled="false"` is
  * valid usage for the disabled property on ion-button.
  */
-const focusableQueryString = '[tabindex]:not([tabindex^="-"]):not([hidden]):not([disabled]), input:not([type=hidden]):not([tabindex^="-"]):not([hidden]):not([disabled]), textarea:not([tabindex^="-"]):not([hidden]):not([disabled]), button:not([tabindex^="-"]):not([hidden]):not([disabled]), select:not([tabindex^="-"]):not([hidden]):not([disabled]), ion-checkbox:not([tabindex^="-"]):not([hidden]):not([disabled]), ion-radio:not([tabindex^="-"]):not([hidden]):not([disabled]), ion-textarea:not([tabindex^="-"]):not([hidden]):not([disabled]), .ion-focusable:not([tabindex^="-"]):not([hidden]):not([disabled]), .ion-focusable[disabled="false"]:not([tabindex^="-"]):not([hidden])';
+const focusableQueryString = '[tabindex]:not([tabindex^="-"]):not([hidden]):not([disabled]), input:not([type=hidden]):not([tabindex^="-"]):not([hidden]):not([disabled]), textarea:not([tabindex^="-"]):not([hidden]):not([disabled]), button:not([tabindex^="-"]):not([hidden]):not([disabled]), select:not([tabindex^="-"]):not([hidden]):not([disabled]), ion-checkbox:not([tabindex^="-"]):not([hidden]):not([disabled]), ion-radio:not([tabindex^="-"]):not([hidden]):not([disabled]), .ion-focusable:not([tabindex^="-"]):not([hidden]):not([disabled]), .ion-focusable[disabled="false"]:not([tabindex^="-"]):not([hidden])';
 /**
  * Focuses the first descendant in a context
  * that can receive focus. If none exists,
@@ -72,18 +219,7 @@ const focusElementInContext = (hostToFocus, fallbackElement) => {
     const shadowRoot = hostToFocus?.shadowRoot;
     if (shadowRoot) {
         // If there are no inner focusable elements, just focus the host element.
-        const innerFocusable = shadowRoot.querySelector(focusableQueryString);
-        // If the host has a setFocus() method, use it to delegate focus properly.
-        // This is needed for shadow DOM components like ion-textarea that override
-        // focus() to delegate to their inner native elements.
-        const hasSetFocus = typeof hostToFocus.setFocus === 'function';
-        if (innerFocusable && hasSetFocus) {
-            // Keep the host element so we can call setFocus() on it
-            elementToFocus = hostToFocus;
-        }
-        else {
-            elementToFocus = innerFocusable || hostToFocus;
-        }
+        elementToFocus = shadowRoot.querySelector(focusableQueryString) || hostToFocus;
     }
     if (elementToFocus) {
         const radioGroup = elementToFocus.closest('ion-radio-group');
@@ -91,7 +227,7 @@ const focusElementInContext = (hostToFocus, fallbackElement) => {
             radioGroup.setFocus();
         }
         else {
-            focusRedirectedElement(elementToFocus);
+            focusVisibleElement(elementToFocus);
         }
     }
     else {
@@ -108,114 +244,8 @@ let lastId = 0;
  */
 const NON_TOAST_OVERLAYS = 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-popover';
 const activeAnimations = new WeakMap();
-const OVERLAY_FOCUS_TRAP_SELECTOR = 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-popover';
-/**
- * The focus trap is generic and knows nothing about which components are
- * inside an overlay. Components mark their elements with these `data-*`
- * attributes, which the trap reads, to control how Tab moves through them.
- * This keeps private component class names (e.g. `.modal-handle`,
- * `.action-sheet-button`) out of the trap, so changing a component does
- *  not silently break Tab order.
- *
- * - `data-focus-ignore`: skip this element as a tab stop.
- * - `data-focus-order`: explicit numeric placement in the tab sequence.
- * - `data-roving-focus`: a container whose focusable descendants share a
- *   single tab stop via a roving tabindex.
- */
-const FOCUS_IGNORE_SELECTOR = '[data-focus-ignore]';
-const FOCUS_ORDER_SELECTOR = '[data-focus-order]';
-const ROVING_FOCUS_SELECTOR = '[data-roving-focus]';
-/**
- * Returns the roving-focus group an element belongs to, or `null`.
- * A member is a descendant of a `[data-roving-focus]` container. The
- * container itself is not a member. Members share a single tab stop.
- */
-const getRovingFocusGroup = (el) => {
-    const group = el.closest(ROVING_FOCUS_SELECTOR);
-    return group !== null && group !== el ? group : null;
-};
-/**
- * Whether an element participates in a roving-focus group.
- */
-const isRovingFocusItem = (el) => getRovingFocusGroup(el) !== null;
-/**
- * Returns the currently focused element for keyboard focus checks.
- *
- * Starts from `document.activeElement` (non-shadow / light DOM focus).
- * If focus is inside one or more open shadow roots
- * (e.g. native control inside `ion-radio`), walks through nested
- * `shadowRoot.activeElement` values until the innermost focused node is reached.
- */
-const getActiveElement = (ownerDoc) => {
-    let active = ownerDoc.activeElement;
-    if (!active) {
-        return null;
-    }
-    while (active.shadowRoot?.activeElement) {
-        active = active.shadowRoot.activeElement;
-    }
-    return active;
-};
 /**
- * Walks from a focused node (possibly deep inside shadow roots) up to
- * the nearest roving-focus host (e.g. `ion-radio` inside an
- * `ion-radio-group`, or an action sheet `<button role="radio">`).
- */
-const getRovingFocusHost = (active) => {
-    let n = active;
-    while (n) {
-        if (isRovingFocusItem(n)) {
-            return n;
-        }
-        const root = n.getRootNode();
-        if (root instanceof ShadowRoot && root.host instanceof HTMLElement) {
-            n = root.host;
-        }
-        else {
-            return null;
-        }
-    }
-    return null;
-};
-/**
- * Reorders focusables for components that declare an explicit tab order
- * via `data-focus-order`. Elements without the attribute keep their
- * visual order and are visited first. Elements with it are appended
- * afterwards, sorted by ascending numeric value.
- *
- * Example (sheet modal): the options have no order and are visited
- * first in visual order, then the drag handle (`data-focus-order="1"`),
- * then the header Cancel button (`data-focus-order="2"`).
- */
-const applyFocusOrder = (elements) => {
-    const sortByVisualPosition = (els) => [...els].sort((a, b) => {
-        const ra = a.getBoundingClientRect();
-        const rb = b.getBoundingClientRect();
-        const topDiff = ra.top - rb.top;
-        if (Math.abs(topDiff) > 1) {
-            return topDiff;
-        }
-        return ra.left - rb.left;
-    });
-    const unordered = elements.filter((el) => !el.matches(FOCUS_ORDER_SELECTOR));
-    const ordered = elements
-        .filter((el) => el.matches(FOCUS_ORDER_SELECTOR))
-        .sort((a, b) => Number(a.getAttribute('data-focus-order')) - Number(b.getAttribute('data-focus-order')));
-    return [...sortByVisualPosition(unordered), ...ordered];
-};
-/**
- * Roving-focus members use a tabindex pattern where only one member is
- * tabbable (`tabIndex="0"`) while the others are not (`tabIndex="-1"`).
- * This returns the index of the current tabbable member.
- */
-const getTabbableRovingFocusIndex = (elements, overlay) => {
-    return elements.findIndex((el) => {
-        return overlay.contains(el) && isRovingFocusItem(el) && el.tabIndex >= 0;
-    });
-};
-/**
- * Determines if the overlay's backdrop is always blocking
- * (no background interaction).
+ * Determines if the overlay's backdrop is always blocking (no background interaction).
  * Returns false if showBackdrop=false or backdropBreakpoint > 0.
  */
 const isBackdropAlwaysBlocking = (el) => {
@@ -324,7 +354,7 @@ const focusElementInOverlay = (hostToFocus, overlay) => {
         elementToFocus = shadowRoot.querySelector(focusableQueryString) || hostToFocus;
     }
     if (elementToFocus) {
-        focusRedirectedElement(elementToFocus);
+        focusVisibleElement(elementToFocus);
     }
     else {
         // Focus overlay instead of letting focus escape
@@ -339,7 +369,7 @@ const focusElementInOverlay = (hostToFocus, overlay) => {
  * Should NOT include: Toast
  */
 const trapKeyboardFocus = (ev, doc) => {
-    const lastOverlay = getPresentedOverlay(doc, OVERLAY_FOCUS_TRAP_SELECTOR);
+    const lastOverlay = getPresentedOverlay(doc, NON_TOAST_OVERLAYS);
     const target = ev.target;
     /**
      * If no active overlay, ignore this event.
@@ -522,174 +552,6 @@ const connectListeners = (doc) => {
         doc.addEventListener('focus', (ev) => {
             trapKeyboardFocus(ev, doc);
         }, true);
-        /**
-         * Remember which roving-focus member last received focus
-         * (arrows, click, or Tab). A roving group keeps `tabIndex=0` on a
-         * single member (e.g. the checked/first radio), so the Tab trap
-         * uses this when wrapping back into the group or focusing its slot.
-         */
-        doc.addEventListener('focusin', (ev) => {
-            const lastOverlay = getPresentedOverlay(doc, OVERLAY_FOCUS_TRAP_SELECTOR);
-            if (!lastOverlay || lastOverlay.classList.contains(FOCUS_TRAP_DISABLE_CLASS)) {
-                return;
-            }
-            const target = ev.target;
-            if (!(target instanceof HTMLElement)) {
-                return;
-            }
-            const rovingHost = getRovingFocusHost(target);
-            if (rovingHost && lastOverlay.contains(rovingHost)) {
-                lastOverlay.trapLastRovingFocus = rovingHost;
-            }
-        }, true);
-        // Listen for keydown events to intercept Tab navigation.
-        // This is needed for Safari and Firefox which may skip focusable
-        // elements or allow focus to escape the overlay.
-        // It also ensures proper focus delegation for shadow DOM elements
-        // like ion-textarea.
-        doc.addEventListener('keydown', (ev) => {
-            if (ev.key !== 'Tab' && ev.key !== 'Alt+Tab')
-                return;
-            const lastOverlay = getPresentedOverlay(doc, OVERLAY_FOCUS_TRAP_SELECTOR);
-            if (!lastOverlay || lastOverlay.classList.contains(FOCUS_TRAP_DISABLE_CLASS))
-                return;
-            const activeElement = getActiveElement(doc);
-            if (activeElement === lastOverlay) {
-                ev.preventDefault();
-                focusFirstDescendant(lastOverlay);
-                return;
-            }
-            // Check if activeElement is inside the overlay (including shadow DOM)
-            const isInsideOverlay = activeElement
-                ? lastOverlay.contains(activeElement) ||
-                    (activeElement.getRootNode() instanceof ShadowRoot &&
-                        lastOverlay.contains(activeElement.getRootNode().host)) ||
-                    (lastOverlay.shadowRoot?.contains(activeElement) ?? false)
-                : false;
-            if (!isInsideOverlay)
-                return;
-            // Get all focusable elements from both light and shadow DOM
-            let allFocusable = [
-                ...lastOverlay.querySelectorAll(focusableQueryString),
-                ...(lastOverlay.shadowRoot?.querySelectorAll(focusableQueryString) || []),
-            ];
-            /**
-             * Some elements match `focusableQueryString` but are not
-             * intended tab stops (e.g. the `ion-item` wrappers a select
-             * modal renders around its options). Components opt these out
-             * with `data-focus-ignore` so Tab can move between the real
-             * controls.
-             */
-            allFocusable = allFocusable.filter((el) => !el.matches(FOCUS_IGNORE_SELECTOR));
-            /**
-             * A roving-focus group is a single tab stop: only its currently
-             * tabbable member (`tabIndex >= 0`) participates. Other
-             * focusables inside the group are not independent tab stops —
-             * this includes inactive members and focusable wrappers such as
-             * the `ion-item` that carries `ion-focusable` on behalf of a
-             * radio. Drop them so Tab moves between the group and the
-             * surrounding controls (e.g. the handle), not into the wrappers.
-             */
-            allFocusable = allFocusable.filter((el) => !isRovingFocusItem(el) || el.tabIndex >= 0);
-            /**
-             * When a component declares an explicit tab order via
-             * `data-focus-order` (e.g. a sheet modal's handle and Cancel
-             * button), reorder accordingly. Overlays that declare no order
-             * keep their DOM order.
-             */
-            if (allFocusable.some((el) => el.matches(FOCUS_ORDER_SELECTOR))) {
-                allFocusable = applyFocusOrder(allFocusable);
-            }
-            if (allFocusable.length === 0) {
-                ev.preventDefault();
-                return;
-            }
-            // Find current element's index (accounting for shadow DOM)
-            let currentIndex = activeElement
-                ? allFocusable.findIndex((el) => {
-                    if (el === activeElement)
-                        return true;
-                    if (el.shadowRoot?.contains(activeElement))
-                        return true;
-                    const rootNode = activeElement.getRootNode();
-                    return rootNode instanceof ShadowRoot && rootNode.host === el;
-                })
-                : -1;
-            /**
-             * A roving-focus group keeps `tabIndex=0` on a single member
-             * while the others are `-1`. Arrow keys can move focus onto a
-             * `tabIndex=-1` member, which `focusableQueryString` excludes,
-             * so `findIndex` yields -1 and Tab would wrap to
-             * `allFocusable[0]`. Treat focus on any group member as the
-             * group's tabbable slot so Tab goes to the next control (e.g.
-             * handle → Cancel), not back to the first member.
-             */
-            if (currentIndex < 0 && activeElement) {
-                const rovingHost = getRovingFocusHost(activeElement);
-                if (rovingHost && lastOverlay.contains(rovingHost)) {
-                    const directIndex = allFocusable.indexOf(rovingHost);
-                    if (directIndex >= 0) {
-                        currentIndex = directIndex;
-                    }
-                    else {
-                        const tabbableIndex = getTabbableRovingFocusIndex(allFocusable, lastOverlay);
-                        if (tabbableIndex >= 0) {
-                            currentIndex = tabbableIndex;
-                        }
-                    }
-                }
-            }
-            ev.preventDefault();
-            // Helper to focus an element, handling shadow DOM properly
-            const focusElement = (element) => {
-                const shadowRoot = element.shadowRoot;
-                if (shadowRoot) {
-                    const innerFocusable = shadowRoot.querySelector(focusableQueryString);
-                    if (innerFocusable && typeof element.setFocus !== 'function') {
-                        focusVisibleElement(innerFocusable);
-                        return;
-                    }
-                }
-                focusVisibleElement(element);
-            };
-            let nextIndex;
-            if (ev.shiftKey) {
-                // Shift+Tab: previous element, wrap to last if at first
-                if (currentIndex <= 0) {
-                    nextIndex = allFocusable.length - 1;
-                }
-                else {
-                    nextIndex = currentIndex - 1;
-                }
-            }
-            else {
-                // Tab: next element, wrap to first if at last
-                if (currentIndex < 0 || currentIndex >= allFocusable.length - 1) {
-                    nextIndex = 0;
-                }
-                else {
-                    nextIndex = currentIndex + 1;
-                }
-            }
-            const nextEl = allFocusable[nextIndex];
-            const overlayTrap = lastOverlay;
-            const tabbableRovingIndex = getTabbableRovingFocusIndex(allFocusable, lastOverlay);
-            /**
-             * The trap list only includes one tabbable member of a roving
-             * group (`tabIndex >= 0`), usually the checked/first radio.
-             * `focusin` tracks the real last-focused member. Use it whenever
-             * Tab would focus that slot (wrap from Cancel, Shift+Tab from
-             * handle, etc.).
-             */
-            let focusTarget = nextEl;
-            if (tabbableRovingIndex >= 0 && nextIndex === tabbableRovingIndex) {
-                const saved = overlayTrap.trapLastRovingFocus;
-                if (saved?.isConnected && lastOverlay.contains(saved) && saved !== nextEl) {
-                    focusTarget = saved;
-                }
-            }
-            focusElement(focusTarget);
-        }, true);
         /**
          * Whether the overlay actually dismisses is checked at press time,
          * since `backdropDismiss` can change while it's open.
@@ -869,7 +731,7 @@ const restoreRootFocusTrapAccessibility = (overlayEl) => {
     }
     applyRootLock(el);
 };
-const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, ionicEnterAnimation, opts) => {
+const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, opts) => {
     if (overlay.presented) {
         return;
     }
@@ -901,15 +763,11 @@ const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, ionic
         applyRootLock(overlayEl);
     }
     overlay.willPresentShorthand?.emit();
-    const theme = getIonTheme(overlay);
     const mode = getIonMode(overlay);
-    const selectedAnimation = mode === 'ios'
-        ? iosEnterAnimation
-        : theme === 'ionic' && ionicEnterAnimation
-            ? ionicEnterAnimation
-            : mdEnterAnimation;
     // get the user's animation fn if one was provided
-    const animationBuilder = overlay.enterAnimation ? overlay.enterAnimation : config.get(name, selectedAnimation);
+    const animationBuilder = overlay.enterAnimation
+        ? overlay.enterAnimation
+        : config.get(name, mode === 'ios' ? iosEnterAnimation : mdEnterAnimation);
     const completed = await overlayAnimation(overlay, animationBuilder, overlay.el, opts);
     if (completed) {
         overlay.didPresent.emit();
@@ -1088,8 +946,7 @@ const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnim
     return true;
 };
 const getAppRoot = (doc) => {
-    const appRootSelector = config.get('appRootSelector', 'ion-app');
-    return doc.querySelector(appRootSelector) || doc.body;
+    return doc.querySelector('ion-app') || doc.body;
 };
 const overlayAnimation = async (overlay, animationBuilder, baseEl, opts) => {
     // Make overlay visible in case it's hidden
@@ -1323,4 +1180,4 @@ const createTriggerController = () => {
 };
 const FOCUS_TRAP_DISABLE_CLASS = 'ion-disable-focus-trap';
 
-export { BACKDROP as B, FOCUS_TRAP_DISABLE_CLASS as F, GESTURE as G, OVERLAY_GESTURE_PRIORITY as O, alertController as a, actionSheetController as b, createDelegateController as c, createTriggerController as d, present as e, dismiss as f, eventMethod as g, prepareOverlay as h, isCancel as i, cleanupRootFocusTrapAccessibility as j, setOverlayId as k, loadingController as l, modalController as m, getOverlaySizeType as n, focusFirstDescendant as o, popoverController as p, getPresentedOverlay as q, restoreRootFocusTrapAccessibility as r, safeCall as s, toastController as t, focusLastDescendant as u };
+export { BACKDROP as B, FOCUS_TRAP_DISABLE_CLASS as F, GESTURE as G, MENU_BACK_BUTTON_PRIORITY as M, OVERLAY_GESTURE_PRIORITY as O, alertController as a, actionSheetController as b, createDelegateController as c, createTriggerController as d, present as e, dismiss as f, eventMethod as g, prepareOverlay as h, isCancel as i, cleanupRootFocusTrapAccessibility as j, setOverlayId as k, loadingController as l, modalController as m, getOverlaySizeType as n, focusFirstDescendant as o, popoverController as p, addCloseWatcherCondition as q, restoreRootFocusTrapAccessibility as r, safeCall as s, toastController as t, getPresentedOverlay as u, focusLastDescendant as v, shouldUseCloseWatcher as w, updateCloseWatcher as x, hardwareBackButton as y };

package/dist/esm/{select-option-render-D5kt0cO9.js → select-option-render-BSDT9oSA.js}

@@ -1,8 +1,8 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { h } from './index-hR6kxzTq.js';
-import { a as sanitizeDOMTree } from './index-BRYliuA-.js';
+import { h } from './index-BpRUsN_W.js';
+import { a as sanitizeDOMTree } from './index-CK8uF0iB.js';
 
 /**
  * Converts a DOM node into a Stencil VNode (or text string) so the