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

package/dist/cjs/{overlays-DziOxcCT.js → overlays-BbVQG3UT.js}

@@ -3,13 +3,160 @@
  */
 'use strict';
 
-var index$1 = require('./index-DkNv4J_i.js');
-var helpers = require('./helpers-DHNLF4fD.js');
-var ionicGlobal = require('./ionic-global-CZX42KL4.js');
-var index = require('./index-CB1PuDlX.js');
-var frameworkDelegate = require('./framework-delegate-CAdDEnFS.js');
+var helpers = require('./helpers-BrETKUUX.js');
+var index = require('./index-BiQyIvoc.js');
+var ionicGlobal = require('./ionic-global-48ceLiJ6.js');
+var frameworkDelegate = require('./framework-delegate-hNMKEiQC.js');
 var gestureController = require('./gesture-controller-CeJslptU.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 = () => index.config.get('experimentalCloseWatcher', false) && helpers.win !== undefined && 'CloseWatcher' in helpers.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$1 = 0;
+        let handlers = [];
+        const ev = new CustomEvent('ionBackButton', {
+            bubbles: false,
+            detail: {
+                register(priority, handler) {
+                    handlers.push({ priority, handler, id: index$1++ });
+                },
+            },
+        });
+        doc.dispatchEvent(ev);
+        const executeAction = async (handlerRegister) => {
+            try {
+                if (handlerRegister?.handler) {
+                    const result = handlerRegister.handler(processHandlers);
+                    if (result != null) {
+                        await result;
+                    }
+                }
+            }
+            catch (e) {
+                index.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 helpers.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
@@ -22,7 +169,7 @@ var gestureController = require('./gesture-controller-CeJslptU.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,
@@ -74,18 +221,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');
@@ -93,7 +229,7 @@ const focusElementInContext = (hostToFocus, fallbackElement) => {
             radioGroup.setFocus();
         }
         else {
-            helpers.focusRedirectedElement(elementToFocus);
+            helpers.focusVisibleElement(elementToFocus);
         }
     }
     else {
@@ -110,114 +246,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) => {
@@ -326,7 +356,7 @@ const focusElementInOverlay = (hostToFocus, overlay) => {
         elementToFocus = shadowRoot.querySelector(focusableQueryString) || hostToFocus;
     }
     if (elementToFocus) {
-        helpers.focusRedirectedElement(elementToFocus);
+        helpers.focusVisibleElement(elementToFocus);
     }
     else {
         // Focus overlay instead of letting focus escape
@@ -341,7 +371,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.
@@ -524,184 +554,16 @@ 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') {
-                        helpers.focusVisibleElement(innerFocusable);
-                        return;
-                    }
-                }
-                helpers.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.
          */
-        ionicGlobal.addCloseWatcherCondition(() => getPresentedOverlay(doc, NON_TOAST_OVERLAYS) !== undefined);
+        addCloseWatcherCondition(() => getPresentedOverlay(doc, NON_TOAST_OVERLAYS) !== undefined);
         // handle back-button click
         doc.addEventListener('ionBackButton', (ev) => {
             const lastOverlay = getPresentedOverlay(doc);
             if (lastOverlay?.backdropDismiss) {
-                ev.detail.register(ionicGlobal.OVERLAY_BACK_BUTTON_PRIORITY, () => {
+                ev.detail.register(OVERLAY_BACK_BUTTON_PRIORITY, () => {
                     /**
                      * Do not return this promise otherwise
                      * the hardware back button utility will
@@ -724,7 +586,7 @@ const connectListeners = (doc) => {
          * this behavior will be handled via the ionBackButton
          * event.
          */
-        if (!ionicGlobal.shouldUseCloseWatcher()) {
+        if (!shouldUseCloseWatcher()) {
             doc.addEventListener('keydown', (ev) => {
                 if (ev.key === 'Escape') {
                     const lastOverlay = getPresentedOverlay(doc);
@@ -830,7 +692,7 @@ const cleanupRootFocusTrapAccessibility = () => {
     if (typeof document === 'undefined') {
         return;
     }
-    ionicGlobal.updateCloseWatcher();
+    updateCloseWatcher();
     const remainingOverlays = getPresentedOverlays(document);
     const hasRemainingLocking = remainingOverlays.some((o) => locksAppRoot(o));
     if (!hasRemainingLocking) {
@@ -864,14 +726,14 @@ const restoreRootFocusTrapAccessibility = (overlayEl) => {
     if (typeof document === 'undefined') {
         return;
     }
-    ionicGlobal.updateCloseWatcher();
+    updateCloseWatcher();
     const el = overlayEl;
     if (!locksAppRoot(el)) {
         return;
     }
     applyRootLock(el);
 };
-const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, ionicEnterAnimation, opts) => {
+const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, opts) => {
     if (overlay.presented) {
         return;
     }
@@ -903,15 +765,11 @@ const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, ionic
         applyRootLock(overlayEl);
     }
     overlay.willPresentShorthand?.emit();
-    const theme = ionicGlobal.getIonTheme(overlay);
     const mode = ionicGlobal.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 : index.config.get(name, selectedAnimation);
+    const animationBuilder = overlay.enterAnimation
+        ? overlay.enterAnimation
+        : index.config.get(name, mode === 'ios' ? iosEnterAnimation : mdEnterAnimation);
     const completed = await overlayAnimation(overlay, animationBuilder, overlay.el, opts);
     if (completed) {
         overlay.didPresent.emit();
@@ -1019,7 +877,7 @@ const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnim
     if (!overlay.presented) {
         return false;
     }
-    const presentedOverlays = index$1.doc !== undefined ? getPresentedOverlays(index$1.doc) : [];
+    const presentedOverlays = helpers.doc !== undefined ? getPresentedOverlays(helpers.doc) : [];
     /**
      * For accessibility, toasts lack focus traps and don't receive
      * `aria-hidden` on the root element when presented.
@@ -1086,12 +944,11 @@ const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnim
      * Release the back button if nothing
      * else is left to close.
      */
-    ionicGlobal.updateCloseWatcher();
+    updateCloseWatcher();
     return true;
 };
 const getAppRoot = (doc) => {
-    const appRootSelector = index.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
@@ -1101,7 +958,7 @@ const overlayAnimation = async (overlay, animationBuilder, baseEl, opts) => {
      * as presented, so back can dismiss it while it
      * animates in.
      */
-    ionicGlobal.updateCloseWatcher();
+    updateCloseWatcher();
     const aniRoot = overlay.el;
     const animation = animationBuilder(aniRoot, opts);
     if (!overlay.animated || !index.config.getBoolean('animated', true)) {
@@ -1328,8 +1185,10 @@ const FOCUS_TRAP_DISABLE_CLASS = 'ion-disable-focus-trap';
 exports.BACKDROP = BACKDROP;
 exports.FOCUS_TRAP_DISABLE_CLASS = FOCUS_TRAP_DISABLE_CLASS;
 exports.GESTURE = GESTURE;
+exports.MENU_BACK_BUTTON_PRIORITY = MENU_BACK_BUTTON_PRIORITY;
 exports.OVERLAY_GESTURE_PRIORITY = OVERLAY_GESTURE_PRIORITY;
 exports.actionSheetController = actionSheetController;
+exports.addCloseWatcherCondition = addCloseWatcherCondition;
 exports.alertController = alertController;
 exports.cleanupRootFocusTrapAccessibility = cleanupRootFocusTrapAccessibility;
 exports.createDelegateController = createDelegateController;
@@ -1340,6 +1199,7 @@ exports.focusFirstDescendant = focusFirstDescendant;
 exports.focusLastDescendant = focusLastDescendant;
 exports.getOverlaySizeType = getOverlaySizeType;
 exports.getPresentedOverlay = getPresentedOverlay;
+exports.hardwareBackButton = hardwareBackButton;
 exports.isCancel = isCancel;
 exports.loadingController = loadingController;
 exports.modalController = modalController;
@@ -1349,4 +1209,6 @@ exports.present = present;
 exports.restoreRootFocusTrapAccessibility = restoreRootFocusTrapAccessibility;
 exports.safeCall = safeCall;
 exports.setOverlayId = setOverlayId;
+exports.shouldUseCloseWatcher = shouldUseCloseWatcher;
 exports.toastController = toastController;
+exports.updateCloseWatcher = updateCloseWatcher;

package/dist/cjs/{select-option-render-X_iZ-xeh.js → select-option-render-CzyhrkOu.js}

@@ -3,8 +3,8 @@
  */
 'use strict';
 
-var index = require('./index-CB1PuDlX.js');
-var index$1 = require('./index-B3s1jjBU.js');
+var index = require('./index-BiQyIvoc.js');
+var index$1 = require('./index-B4ONUQRp.js');
 
 /**
  * Converts a DOM node into a Stencil VNode (or text string) so the