@ionic/react-router 8.8.1-dev.11772789669.186f42ce → 8.8.1-dev.11773168858.1f9c0eb8

package/dist/index.js

@@ -1,176 +1,1130 @@
 import { __rest } from 'tslib';
-import { createBrowserHistory, createHashHistory } from 'history';
-import React from 'react';
-import { withRouter, Router } from 'react-router-dom';
+import React, { useRef, useState, useEffect, useCallback } from 'react';
+import { Route, matchPath as matchPath$1, Routes, Navigate, UNSAFE_RouteContext, useLocation, useNavigate, BrowserRouter, useNavigationType, HashRouter } from 'react-router-dom';
 import { ViewStacks, generateId, IonRoute, ViewLifeCycleManager, StackContext, RouteManagerContext, getConfig, LocationHistory, NavManager } from '@ionic/react';
-import { Route, matchPath as matchPath$1, Router as Router$1 } from 'react-router';
+import { MemoryRouter, useLocation as useLocation$1, useNavigationType as useNavigationType$1 } from 'react-router';
 
-class IonRouteInner extends React.PureComponent {
-    render() {
-        return (React.createElement(Route, Object.assign({ path: this.props.path, exact: this.props.exact, render: this.props.render }, (this.props.computedMatch !== undefined
-            ? {
-                computedMatch: this.props.computedMatch,
+const IonRouteInner = ({ path, element }) => {
+    return React.createElement(Route, { path: path, element: element });
+};
+
+/**
+ * The matchPath function is used only for matching paths, not rendering components or elements.
+ * @see https://reactrouter.com/v6/utils/match-path
+ */
+const matchPath = ({ pathname, componentProps }) => {
+    var _a, _b;
+    const { path, index } = componentProps, restProps = __rest(componentProps, ["path", "index"]);
+    // Handle index routes - they match when pathname is empty or just "/"
+    if (index && !path) {
+        if (pathname === '' || pathname === '/') {
+            return {
+                params: {},
+                pathname: pathname,
+                pathnameBase: pathname || '/',
+                pattern: {
+                    path: '',
+                    caseSensitive: false,
+                    end: true,
+                },
+            };
+        }
+        return null;
+    }
+    // Handle empty path routes - they match when pathname is also empty or just "/"
+    if (path === '' || path === undefined) {
+        if (pathname === '' || pathname === '/') {
+            return {
+                params: {},
+                pathname: pathname,
+                pathnameBase: pathname || '/',
+                pattern: {
+                    path: '',
+                    caseSensitive: (_a = restProps.caseSensitive) !== null && _a !== void 0 ? _a : false,
+                    end: (_b = restProps.end) !== null && _b !== void 0 ? _b : true,
+                },
+            };
+        }
+        return null;
+    }
+    // For relative paths (don't start with '/'), normalize both path and pathname for matching
+    if (!path.startsWith('/')) {
+        const matchOptions = Object.assign({ path: `/${path}` }, restProps);
+        if ((matchOptions === null || matchOptions === void 0 ? void 0 : matchOptions.end) === undefined) {
+            matchOptions.end = !path.endsWith('*');
+        }
+        const normalizedPathname = pathname.startsWith('/') ? pathname : `/${pathname}`;
+        const match = matchPath$1(matchOptions, normalizedPathname);
+        if (match) {
+            // Adjust the match to remove the leading '/' we added
+            return Object.assign(Object.assign({}, match), { pathname: pathname, pathnameBase: match.pathnameBase === '/' ? '' : match.pathnameBase.slice(1), pattern: Object.assign(Object.assign({}, match.pattern), { path: path }) });
+        }
+        return null;
+    }
+    // For absolute paths, use React Router's matcher directly.
+    // React Router v6 routes default to `end: true` unless the pattern
+    // explicitly opts into wildcards with `*`. Mirror that behaviour so
+    // matching parity stays aligned with <Route>.
+    const matchOptions = Object.assign({ path }, restProps);
+    if ((matchOptions === null || matchOptions === void 0 ? void 0 : matchOptions.end) === undefined) {
+        matchOptions.end = !path.endsWith('*');
+    }
+    return matchPath$1(matchOptions, pathname);
+};
+/**
+ * Determines the portion of a pathname that a given route pattern should match against.
+ * For absolute route patterns we return the full pathname. For relative patterns we
+ * strip off the already-matched parent segments so React Router receives the remainder.
+ */
+const derivePathnameToMatch = (fullPathname, routePath) => {
+    var _a;
+    // For absolute or empty routes, use the full pathname as-is
+    if (!routePath || routePath === '' || routePath.startsWith('/')) {
+        return fullPathname;
+    }
+    const trimmedPath = fullPathname.startsWith('/') ? fullPathname.slice(1) : fullPathname;
+    if (!trimmedPath) {
+        // For root-level relative routes (pathname is "/" and routePath is relative),
+        // return the full pathname so matchPath can normalize both.
+        // This allows routes like <Route path="foo/*" .../> at root level to work correctly.
+        return fullPathname;
+    }
+    const fullSegments = trimmedPath.split('/').filter(Boolean);
+    if (fullSegments.length === 0) {
+        return '';
+    }
+    const routeSegments = routePath.split('/').filter(Boolean);
+    if (routeSegments.length === 0) {
+        return trimmedPath;
+    }
+    const wildcardIndex = routeSegments.findIndex((segment) => segment === '*' || segment === '**');
+    if (wildcardIndex >= 0) {
+        const baseSegments = routeSegments.slice(0, wildcardIndex);
+        if (baseSegments.length === 0) {
+            return trimmedPath;
+        }
+        const startIndex = fullSegments.findIndex((_, idx) => baseSegments.every((seg, segIdx) => {
+            const target = fullSegments[idx + segIdx];
+            if (!target) {
+                return false;
+            }
+            if (seg.startsWith(':')) {
+                return true;
             }
-            : {}))));
+            return target === seg;
+        }));
+        if (startIndex >= 0) {
+            return fullSegments.slice(startIndex).join('/');
+        }
     }
-}
+    if (routeSegments.length <= fullSegments.length) {
+        return fullSegments.slice(fullSegments.length - routeSegments.length).join('/');
+    }
+    return (_a = fullSegments[fullSegments.length - 1]) !== null && _a !== void 0 ? _a : trimmedPath;
+};
 
 /**
- * @see https://v5.reactrouter.com/web/api/matchPath
+ * Finds the longest common prefix among an array of paths.
+ * Used to determine the scope of an outlet with absolute routes.
+ *
+ * @param paths An array of absolute path strings.
+ * @returns The common prefix shared by all paths.
  */
-const matchPath = ({ pathname, componentProps, }) => {
-    const { exact, component } = componentProps;
-    const path = componentProps.path || componentProps.from;
-    /***
-     * The props to match against, they are identical
-     * to the matching props `Route` accepts. It could also be a string
-     * or an array of strings as shortcut for `{ path }`.
-     */
-    const matchProps = {
-        exact,
-        path,
-        component,
-    };
-    const match = matchPath$1(pathname, matchProps);
-    if (!match) {
+const computeCommonPrefix = (paths) => {
+    if (paths.length === 0)
+        return '';
+    if (paths.length === 1) {
+        // For a single path, extract the directory-like prefix
+        // e.g., /dynamic-routes/home -> /dynamic-routes
+        const segments = paths[0].split('/').filter(Boolean);
+        if (segments.length > 1) {
+            return '/' + segments.slice(0, -1).join('/');
+        }
+        return '/' + segments[0];
+    }
+    // Split all paths into segments
+    const segmentArrays = paths.map((p) => p.split('/').filter(Boolean));
+    const minLength = Math.min(...segmentArrays.map((s) => s.length));
+    const commonSegments = [];
+    for (let i = 0; i < minLength; i++) {
+        const segment = segmentArrays[0][i];
+        // Skip segments with route parameters or wildcards
+        if (segment.includes(':') || segment.includes('*')) {
+            break;
+        }
+        const allMatch = segmentArrays.every((s) => s[i] === segment);
+        if (allMatch) {
+            commonSegments.push(segment);
+        }
+        else {
+            break;
+        }
+    }
+    return commonSegments.length > 0 ? '/' + commonSegments.join('/') : '';
+};
+/**
+ * Checks if a route path is a "splat-only" route (just `*` or `/*`).
+ */
+const isSplatOnlyRoute = (routePath) => {
+    return routePath === '*' || routePath === '/*';
+};
+/**
+ * Checks if a route has an embedded wildcard (e.g., "tab1/*" but not "*" or "/*").
+ */
+const hasEmbeddedWildcard = (routePath) => {
+    return !!routePath && routePath.includes('*') && !isSplatOnlyRoute(routePath);
+};
+/**
+ * Checks if a route with an embedded wildcard matches a pathname.
+ */
+const matchesEmbeddedWildcardRoute = (route, pathname) => {
+    const routePath = route.props.path;
+    if (!hasEmbeddedWildcard(routePath)) {
         return false;
     }
-    return match;
+    return !!matchPath({ pathname, componentProps: route.props });
+};
+/**
+ * Checks if a route is a specific match (not wildcard-only or index).
+ */
+const isSpecificRouteMatch = (route, remainingPath) => {
+    const routePath = route.props.path;
+    if (route.props.index || isSplatOnlyRoute(routePath)) {
+        return false;
+    }
+    return !!matchPath({ pathname: remainingPath, componentProps: route.props });
+};
+/**
+ * Analyzes route children to determine their characteristics.
+ *
+ * @param routeChildren The route children to analyze.
+ * @returns Analysis of the route characteristics.
+ */
+const analyzeRouteChildren = (routeChildren) => {
+    const hasRelativeRoutes = routeChildren.some((route) => {
+        const path = route.props.path;
+        return path && !path.startsWith('/') && path !== '*';
+    });
+    const hasIndexRoute = routeChildren.some((route) => route.props.index);
+    const hasWildcardRoute = routeChildren.some((route) => {
+        const routePath = route.props.path;
+        return routePath === '*' || routePath === '/*';
+    });
+    return { hasRelativeRoutes, hasIndexRoute, hasWildcardRoute, routeChildren };
+};
+/**
+ * Checks if any route matches as a specific (non-wildcard, non-index) route.
+ */
+const findSpecificMatch = (routeChildren, remainingPath) => {
+    return routeChildren.some((route) => isSpecificRouteMatch(route, remainingPath) || matchesEmbeddedWildcardRoute(route, remainingPath));
+};
+/**
+ * Checks if any specific route could plausibly match the remaining path.
+ * Used to determine if we should fall back to a wildcard match.
+ */
+const couldSpecificRouteMatch = (routeChildren, remainingPath) => {
+    const remainingFirstSegment = remainingPath.split('/')[0];
+    return routeChildren.some((route) => {
+        const routePath = route.props.path;
+        if (!routePath || routePath === '*' || routePath === '/*')
+            return false;
+        if (route.props.index)
+            return false;
+        const routeFirstSegment = routePath.split('/')[0].replace(/[*:]/g, '');
+        if (!routeFirstSegment)
+            return false;
+        // Check for prefix overlap (either direction)
+        return (routeFirstSegment.startsWith(remainingFirstSegment.slice(0, 3)) ||
+            remainingFirstSegment.startsWith(routeFirstSegment.slice(0, 3)));
+    });
+};
+/**
+ * Checks for index route match when remaining path is empty.
+ * Index routes only match at the outlet's mount path level.
+ */
+const checkIndexMatch = (parentPath, remainingPath, hasIndexRoute, outletMountPath) => {
+    if ((remainingPath === '' || remainingPath === '/') && hasIndexRoute) {
+        if (outletMountPath) {
+            // Index should only match at the existing mount path
+            return parentPath === outletMountPath ? parentPath : undefined;
+        }
+        // No mount path yet - this would establish it
+        return parentPath;
+    }
+    return undefined;
+};
+/**
+ * Determines the best parent path from the available matches.
+ * Priority: specific > wildcard > index
+ */
+const selectBestMatch = (specificMatch, wildcardMatch, indexMatch) => {
+    var _a;
+    return (_a = specificMatch !== null && specificMatch !== void 0 ? specificMatch : wildcardMatch) !== null && _a !== void 0 ? _a : indexMatch;
+};
+/**
+ * Handles outlets with only absolute routes by computing their common prefix.
+ */
+const computeAbsoluteRoutesParentPath = (routeChildren, currentPathname, outletMountPath) => {
+    const absolutePathRoutes = routeChildren.filter((route) => {
+        const path = route.props.path;
+        return path && path.startsWith('/');
+    });
+    if (absolutePathRoutes.length === 0) {
+        return undefined;
+    }
+    const absolutePaths = absolutePathRoutes.map((r) => r.props.path);
+    const commonPrefix = computeCommonPrefix(absolutePaths);
+    if (!commonPrefix || commonPrefix === '/') {
+        return undefined;
+    }
+    const newOutletMountPath = outletMountPath || commonPrefix;
+    if (!currentPathname.startsWith(commonPrefix)) {
+        return { parentPath: undefined, outletMountPath: newOutletMountPath };
+    }
+    return { parentPath: commonPrefix, outletMountPath: newOutletMountPath };
+};
+/**
+ * Computes the parent path for a nested outlet based on the current pathname
+ * and the outlet's route configuration.
+ *
+ * The algorithm finds the shortest parent path where a route matches the remaining path.
+ * Priority: specific routes > wildcard routes > index routes (only at mount point)
+ *
+ * @param options The options for computing the parent path.
+ * @returns The computed parent path result.
+ */
+const computeParentPath = (options) => {
+    const { currentPathname, outletMountPath, routeChildren, hasRelativeRoutes, hasIndexRoute, hasWildcardRoute } = options;
+    // If pathname is outside the established mount path scope, skip computation
+    if (outletMountPath && !currentPathname.startsWith(outletMountPath)) {
+        return { parentPath: undefined, outletMountPath };
+    }
+    if ((hasRelativeRoutes || hasIndexRoute) && currentPathname.includes('/')) {
+        const segments = currentPathname.split('/').filter(Boolean);
+        if (segments.length >= 1) {
+            let firstSpecificMatch;
+            let firstWildcardMatch;
+            let indexMatchAtMount;
+            // Iterate through path segments to find the shortest matching parent path
+            for (let i = 1; i <= segments.length; i++) {
+                const parentPath = '/' + segments.slice(0, i).join('/');
+                const remainingPath = segments.slice(i).join('/');
+                // Check for specific route match (highest priority)
+                if (!firstSpecificMatch && findSpecificMatch(routeChildren, remainingPath)) {
+                    firstSpecificMatch = parentPath;
+                    break;
+                }
+                // Check for wildcard match (only if remaining path is non-empty)
+                const hasNonEmptyRemaining = remainingPath !== '' && remainingPath !== '/';
+                if (!firstWildcardMatch && hasNonEmptyRemaining && hasWildcardRoute) {
+                    if (!couldSpecificRouteMatch(routeChildren, remainingPath)) {
+                        firstWildcardMatch = parentPath;
+                    }
+                }
+                // Check for index route match
+                const indexMatch = checkIndexMatch(parentPath, remainingPath, hasIndexRoute, outletMountPath);
+                if (indexMatch) {
+                    indexMatchAtMount = indexMatch;
+                }
+            }
+            // Fallback: check root level for embedded wildcard routes (e.g., "tab1/*")
+            if (!firstSpecificMatch) {
+                const fullRemainingPath = segments.join('/');
+                if (routeChildren.some((route) => matchesEmbeddedWildcardRoute(route, fullRemainingPath))) {
+                    firstSpecificMatch = '/';
+                }
+            }
+            const bestPath = selectBestMatch(firstSpecificMatch, firstWildcardMatch, indexMatchAtMount);
+            // Establish mount path on first successful match
+            const newOutletMountPath = outletMountPath || bestPath;
+            if (newOutletMountPath && !currentPathname.startsWith(newOutletMountPath)) {
+                return { parentPath: undefined, outletMountPath: newOutletMountPath };
+            }
+            return { parentPath: bestPath, outletMountPath: newOutletMountPath };
+        }
+    }
+    // Handle outlets with only absolute routes
+    if (!hasRelativeRoutes && !hasIndexRoute) {
+        const result = computeAbsoluteRoutesParentPath(routeChildren, currentPathname, outletMountPath);
+        if (result) {
+            return result;
+        }
+    }
+    return { parentPath: outletMountPath, outletMountPath };
+};
+
+/**
+ * Ensures the given path has a leading slash.
+ *
+ * @param value The path string to normalize.
+ * @returns The path with a leading slash.
+ */
+const ensureLeadingSlash = (value) => {
+    if (value === '') {
+        return '/';
+    }
+    return value.startsWith('/') ? value : `/${value}`;
+};
+/**
+ * Strips the trailing slash from a path, unless it's the root path.
+ *
+ * @param value The path string to normalize.
+ * @returns The path without a trailing slash.
+ */
+const stripTrailingSlash = (value) => {
+    return value.length > 1 && value.endsWith('/') ? value.slice(0, -1) : value;
+};
+/**
+ * Normalizes a pathname for comparison by ensuring a leading slash
+ * and removing trailing slashes.
+ *
+ * @param value The pathname to normalize, can be undefined.
+ * @returns A normalized pathname string.
+ */
+const normalizePathnameForComparison = (value) => {
+    if (!value || value === '') {
+        return '/';
+    }
+    const withLeadingSlash = ensureLeadingSlash(value);
+    return stripTrailingSlash(withLeadingSlash);
+};
+
+/**
+ * Extracts the children from a Routes wrapper component.
+ * The use of `<Routes />` is encouraged with React Router v6.
+ *
+ * @param node The React node to extract Routes children from.
+ * @returns The children of the Routes component, or undefined if not found.
+ */
+const getRoutesChildren = (node) => {
+    let routesNode;
+    React.Children.forEach(node, (child) => {
+        if (child.type === Routes) {
+            routesNode = child;
+        }
+    });
+    if (routesNode) {
+        // The children of the `<Routes />` component are most likely
+        // (and should be) the `<Route />` components.
+        return routesNode.props.children;
+    }
+    return undefined;
+};
+/**
+ * Extracts Route children from a node (either directly or from a Routes wrapper).
+ *
+ * @param children The children to extract routes from.
+ * @returns An array of Route elements.
+ */
+const extractRouteChildren = (children) => {
+    var _a;
+    const routesChildren = (_a = getRoutesChildren(children)) !== null && _a !== void 0 ? _a : children;
+    return React.Children.toArray(routesChildren).filter((child) => React.isValidElement(child) && child.type === Route);
+};
+/**
+ * Checks if a React element is a Navigate component (redirect).
+ *
+ * @param element The element to check.
+ * @returns True if the element is a Navigate component.
+ */
+const isNavigateElement = (element) => {
+    return (React.isValidElement(element) &&
+        (element.type === Navigate || (typeof element.type === 'function' && element.type.name === 'Navigate')));
+};
+
+/**
+ * Sorts view items by route specificity (most specific first).
+ * - Exact matches (no wildcards/params) come first
+ * - Among wildcard routes, longer paths are more specific
+ *
+ * @param views The view items to sort.
+ * @returns A new sorted array of view items.
+ */
+const sortViewsBySpecificity = (views) => {
+    return [...views].sort((a, b) => {
+        var _a, _b, _c, _d;
+        const pathA = ((_b = (_a = a.routeData) === null || _a === void 0 ? void 0 : _a.childProps) === null || _b === void 0 ? void 0 : _b.path) || '';
+        const pathB = ((_d = (_c = b.routeData) === null || _c === void 0 ? void 0 : _c.childProps) === null || _d === void 0 ? void 0 : _d.path) || '';
+        // Exact matches (no wildcards/params) come first
+        const aHasWildcard = pathA.includes('*') || pathA.includes(':');
+        const bHasWildcard = pathB.includes('*') || pathB.includes(':');
+        if (!aHasWildcard && bHasWildcard)
+            return -1;
+        if (aHasWildcard && !bHasWildcard)
+            return 1;
+        // Among wildcard routes, longer paths are more specific
+        return pathB.length - pathA.length;
+    });
 };
 
+/**
+ * `ReactRouterViewStack` is a custom navigation manager used in Ionic React
+ * apps to map React Router route elements (such as `<IonRoute>`) to "view
+ * items" that Ionic can manage in a view stack. This is critical to maintain
+ * Ionic’s animation, lifecycle, and history behavior across views.
+ */
+/**
+ * Delay in milliseconds before removing a Navigate view item after a redirect.
+ * This ensures the redirect navigation completes before the view is removed.
+ */
+const NAVIGATE_REDIRECT_DELAY_MS = 100;
+/**
+ * Delay in milliseconds before cleaning up a view without an IonPage element.
+ * This double-checks that the view is truly not needed before removal.
+ */
+const VIEW_CLEANUP_DELAY_MS = 200;
+/**
+ * Computes the absolute pathnameBase for a route element based on its type.
+ * Handles relative paths, index routes, and splat routes differently.
+ */
+const computeAbsolutePathnameBase = (routeElement, routeMatch, parentPathnameBase, routeInfoPathname) => {
+    const routePath = routeElement.props.path;
+    const isRelativePath = routePath && !routePath.startsWith('/');
+    const isIndexRoute = !!routeElement.props.index;
+    const isSplatOnlyRoute = routePath === '*' || routePath === '/*';
+    if (isSplatOnlyRoute) {
+        // Splat routes should NOT contribute their matched portion to pathnameBase
+        // This aligns with React Router v7's v7_relativeSplatPath behavior
+        return parentPathnameBase;
+    }
+    if (isRelativePath && (routeMatch === null || routeMatch === void 0 ? void 0 : routeMatch.pathnameBase)) {
+        const relativeBase = routeMatch.pathnameBase.startsWith('/')
+            ? routeMatch.pathnameBase.slice(1)
+            : routeMatch.pathnameBase;
+        return parentPathnameBase === '/' ? `/${relativeBase}` : `${parentPathnameBase}/${relativeBase}`;
+    }
+    if (isIndexRoute) {
+        return parentPathnameBase;
+    }
+    return (routeMatch === null || routeMatch === void 0 ? void 0 : routeMatch.pathnameBase) || routeInfoPathname;
+};
+/**
+ * Gets fallback params from view items in other outlets when parent context is empty.
+ * This handles cases where React context propagation doesn't work as expected.
+ */
+const getFallbackParamsFromViewItems = (allViewItems, currentOutletId, currentPathname) => {
+    var _a;
+    const params = {};
+    for (const otherViewItem of allViewItems) {
+        if (otherViewItem.outletId === currentOutletId)
+            continue;
+        const otherMatch = (_a = otherViewItem.routeData) === null || _a === void 0 ? void 0 : _a.match;
+        if ((otherMatch === null || otherMatch === void 0 ? void 0 : otherMatch.params) && Object.keys(otherMatch.params).length > 0) {
+            const matchedPathname = otherMatch.pathnameBase || otherMatch.pathname;
+            if (matchedPathname && currentPathname.startsWith(matchedPathname)) {
+                Object.assign(params, otherMatch.params);
+            }
+        }
+    }
+    return params;
+};
+/**
+ * Builds the matches array for RouteContext.
+ */
+const buildContextMatches = (parentMatches, combinedParams, routeMatch, routeInfoPathname, absolutePathnameBase, viewItem, routeElement, componentElement) => {
+    return [
+        ...parentMatches,
+        {
+            params: combinedParams,
+            pathname: (routeMatch === null || routeMatch === void 0 ? void 0 : routeMatch.pathname) || routeInfoPathname,
+            pathnameBase: absolutePathnameBase,
+            route: {
+                id: viewItem.id,
+                path: routeElement.props.path,
+                element: componentElement,
+                index: !!routeElement.props.index,
+                caseSensitive: routeElement.props.caseSensitive,
+                hasErrorBoundary: false,
+            },
+        },
+    ];
+};
+const createDefaultMatch = (fullPathname, routeProps) => {
+    var _a, _b;
+    const isIndexRoute = !!routeProps.index;
+    const patternPath = (_a = routeProps.path) !== null && _a !== void 0 ? _a : '';
+    const pathnameBase = fullPathname === '' ? '/' : fullPathname;
+    const computedEnd = routeProps.end !== undefined ? routeProps.end : patternPath !== '' ? !patternPath.endsWith('*') : true;
+    return {
+        params: {},
+        pathname: isIndexRoute ? '' : fullPathname,
+        pathnameBase,
+        pattern: {
+            path: patternPath,
+            caseSensitive: (_b = routeProps.caseSensitive) !== null && _b !== void 0 ? _b : false,
+            end: isIndexRoute ? true : computedEnd,
+        },
+    };
+};
+const computeRelativeToParent = (pathname, parentPath) => {
+    if (!parentPath)
+        return null;
+    const normalizedParent = normalizePathnameForComparison(parentPath);
+    const normalizedPathname = normalizePathnameForComparison(pathname);
+    if (normalizedPathname === normalizedParent) {
+        return '';
+    }
+    const withSlash = normalizedParent === '/' ? '/' : normalizedParent + '/';
+    if (normalizedPathname.startsWith(withSlash)) {
+        return normalizedPathname.slice(withSlash.length);
+    }
+    return null;
+};
+const resolveIndexRouteMatch = (viewItem, pathname, parentPath) => {
+    var _a, _b, _c;
+    if (!((_b = (_a = viewItem.routeData) === null || _a === void 0 ? void 0 : _a.childProps) === null || _b === void 0 ? void 0 : _b.index)) {
+        return null;
+    }
+    // Prefer computing against the parent path when available to align with RRv6 semantics
+    const relative = computeRelativeToParent(pathname, parentPath);
+    if (relative !== null) {
+        // Index routes match only when there is no remaining path
+        if (relative === '' || relative === '/') {
+            return createDefaultMatch(parentPath || pathname, viewItem.routeData.childProps);
+        }
+        return null;
+    }
+    // Fallback: use previously computed match base for equality check
+    const previousMatch = (_c = viewItem.routeData) === null || _c === void 0 ? void 0 : _c.match;
+    if (!previousMatch) {
+        return null;
+    }
+    const normalizedPathname = normalizePathnameForComparison(pathname);
+    const normalizedBase = normalizePathnameForComparison(previousMatch.pathnameBase || previousMatch.pathname || '');
+    return normalizedPathname === normalizedBase ? previousMatch : null;
+};
 class ReactRouterViewStack extends ViewStacks {
     constructor() {
         super();
-        this.createViewItem = this.createViewItem.bind(this);
-        this.findViewItemByRouteInfo = this.findViewItemByRouteInfo.bind(this);
-        this.findLeavingViewItemByRouteInfo = this.findLeavingViewItemByRouteInfo.bind(this);
-        this.getChildrenToRender = this.getChildrenToRender.bind(this);
-        this.findViewItemByPathname = this.findViewItemByPathname.bind(this);
-    }
-    createViewItem(outletId, reactElement, routeInfo, page) {
-        const viewItem = {
-            id: generateId('viewItem'),
-            outletId,
-            ionPageElement: page,
-            reactElement,
-            mount: true,
-            ionRoute: false,
-        };
-        if (reactElement.type === IonRoute) {
-            viewItem.ionRoute = true;
-            viewItem.disableIonPageManagement = reactElement.props.disableIonPageManagement;
-        }
-        viewItem.routeData = {
-            match: matchPath({
-                pathname: routeInfo.pathname,
-                componentProps: reactElement.props,
-            }),
-            childProps: reactElement.props,
-        };
-        return viewItem;
-    }
-    getChildrenToRender(outletId, ionRouterOutlet, routeInfo) {
-        const viewItems = this.getViewItemsForOutlet(outletId);
-        // Sync latest routes with viewItems
-        React.Children.forEach(ionRouterOutlet.props.children, (child) => {
-            const viewItem = viewItems.find((v) => {
-                return matchComponent$1(child, v.routeData.childProps.path || v.routeData.childProps.from);
+        /**
+         * Creates a new view item for the given outlet and react route element.
+         * Associates route props with the matched route path for further lookups.
+         */
+        this.createViewItem = (outletId, reactElement, routeInfo, page) => {
+            var _a, _b;
+            const routePath = reactElement.props.path || '';
+            // Check if we already have a view item for this exact route that we can reuse
+            // Include wildcard routes like tabs/* since they should be reused
+            // Also check unmounted items that might have been preserved for browser navigation
+            const existingViewItem = this.getViewItemsForOutlet(outletId).find((v) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h;
+                const existingRouteProps = (_b = (_a = v.reactElement) === null || _a === void 0 ? void 0 : _a.props) !== null && _b !== void 0 ? _b : {};
+                const existingPath = existingRouteProps.path || '';
+                const existingElement = existingRouteProps.element;
+                const newElement = reactElement.props.element;
+                const existingIsIndexRoute = !!existingRouteProps.index;
+                const newIsIndexRoute = !!reactElement.props.index;
+                // For Navigate components, match by destination
+                const existingIsNavigate = React.isValidElement(existingElement) && existingElement.type === Navigate;
+                const newIsNavigate = React.isValidElement(newElement) && newElement.type === Navigate;
+                if (existingIsNavigate && newIsNavigate) {
+                    const existingTo = (_c = existingElement.props) === null || _c === void 0 ? void 0 : _c.to;
+                    const newTo = (_d = newElement.props) === null || _d === void 0 ? void 0 : _d.to;
+                    if (existingTo === newTo) {
+                        return true;
+                    }
+                }
+                if (existingIsIndexRoute && newIsIndexRoute) {
+                    return true;
+                }
+                // Reuse view items with the same path
+                // Special case: reuse tabs/* and other specific wildcard routes
+                // Don't reuse index routes (empty path) or generic catch-all wildcards (*)
+                if (existingPath === routePath && existingPath !== '' && existingPath !== '*') {
+                    // Parameterized routes need pathname matching to ensure /details/1 and /details/2
+                    // get separate view items. For wildcard routes (e.g., user/:userId/*), compare
+                    // pathnameBase to allow child path changes while preserving the parent view.
+                    const hasParams = routePath.includes(':');
+                    const isWildcard = routePath.includes('*');
+                    if (hasParams) {
+                        if (isWildcard) {
+                            const existingPathnameBase = (_f = (_e = v.routeData) === null || _e === void 0 ? void 0 : _e.match) === null || _f === void 0 ? void 0 : _f.pathnameBase;
+                            const newMatch = matchComponent$1(reactElement, routeInfo.pathname, false);
+                            const newPathnameBase = newMatch === null || newMatch === void 0 ? void 0 : newMatch.pathnameBase;
+                            if (existingPathnameBase !== newPathnameBase) {
+                                return false;
+                            }
+                        }
+                        else {
+                            const existingPathname = (_h = (_g = v.routeData) === null || _g === void 0 ? void 0 : _g.match) === null || _h === void 0 ? void 0 : _h.pathname;
+                            if (existingPathname !== routeInfo.pathname) {
+                                return false;
+                            }
+                        }
+                    }
+                    return true;
+                }
+                // Also reuse specific wildcard routes like tabs/*
+                if (existingPath === routePath && existingPath.endsWith('/*') && existingPath !== '/*') {
+                    return true;
+                }
+                return false;
             });
-            if (viewItem) {
-                viewItem.reactElement = child;
+            if (existingViewItem) {
+                // Update and ensure the existing view item is properly configured
+                existingViewItem.reactElement = reactElement;
+                existingViewItem.mount = true;
+                existingViewItem.ionPageElement = page || existingViewItem.ionPageElement;
+                const updatedMatch = matchComponent$1(reactElement, routeInfo.pathname, false) ||
+                    ((_a = existingViewItem.routeData) === null || _a === void 0 ? void 0 : _a.match) ||
+                    createDefaultMatch(routeInfo.pathname, reactElement.props);
+                existingViewItem.routeData = {
+                    match: updatedMatch,
+                    childProps: reactElement.props,
+                    lastPathname: (_b = existingViewItem.routeData) === null || _b === void 0 ? void 0 : _b.lastPathname, // Preserve navigation history
+                };
+                return existingViewItem;
             }
-        });
-        const children = viewItems.map((viewItem) => {
-            let clonedChild;
-            if (viewItem.ionRoute && !viewItem.disableIonPageManagement) {
-                clonedChild = (React.createElement(ViewLifeCycleManager, { key: `view-${viewItem.id}`, mount: viewItem.mount, removeView: () => this.remove(viewItem) }, React.cloneElement(viewItem.reactElement, {
-                    computedMatch: viewItem.routeData.match,
-                })));
+            const id = `${outletId}-${generateId(outletId)}`;
+            const viewItem = {
+                id,
+                outletId,
+                ionPageElement: page,
+                reactElement,
+                mount: true,
+                ionRoute: true,
+            };
+            if (reactElement.type === IonRoute) {
+                viewItem.disableIonPageManagement = reactElement.props.disableIonPageManagement;
             }
-            else {
-                const match = matchComponent$1(viewItem.reactElement, routeInfo.pathname);
-                clonedChild = (React.createElement(ViewLifeCycleManager, { key: `view-${viewItem.id}`, mount: viewItem.mount, removeView: () => this.remove(viewItem) }, React.cloneElement(viewItem.reactElement, {
-                    computedMatch: viewItem.routeData.match,
-                })));
-                if (!match && viewItem.routeData.match) {
-                    viewItem.routeData.match = undefined;
+            const initialMatch = matchComponent$1(reactElement, routeInfo.pathname, true) ||
+                createDefaultMatch(routeInfo.pathname, reactElement.props);
+            viewItem.routeData = {
+                match: initialMatch,
+                childProps: reactElement.props,
+            };
+            this.add(viewItem);
+            return viewItem;
+        };
+        /**
+         * Renders a ViewLifeCycleManager for the given view item.
+         * Handles cleanup if the view no longer matches.
+         *
+         * - Deactivates view if it no longer matches the current route
+         * - Wraps the route element in <Routes> to support nested routing and ensure remounting
+         * - Adds a unique key to <Routes> so React Router remounts routes when switching
+         */
+        this.renderViewItem = (viewItem, routeInfo, parentPath) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const routePath = viewItem.reactElement.props.path || '';
+            let match = matchComponent$1(viewItem.reactElement, routeInfo.pathname);
+            if (!match) {
+                const indexMatch = resolveIndexRouteMatch(viewItem, routeInfo.pathname, parentPath);
+                if (indexMatch) {
+                    match = indexMatch;
+                }
+            }
+            // For parameterized routes, check if this is a navigation to a different path instance
+            // In that case, we should NOT reuse this view - a new view should be created
+            const isParameterRoute = routePath.includes(':');
+            const previousMatch = (_a = viewItem.routeData) === null || _a === void 0 ? void 0 : _a.match;
+            const isSamePath = (match === null || match === void 0 ? void 0 : match.pathname) === (previousMatch === null || previousMatch === void 0 ? void 0 : previousMatch.pathname);
+            // Flag to indicate this view should not be reused for this different parameterized path
+            const shouldSkipForDifferentParam = isParameterRoute && match && previousMatch && !isSamePath;
+            // Don't deactivate views automatically - let the StackManager handle view lifecycle
+            // This preserves views in the stack for navigation history like native apps
+            // Views will be hidden/shown by the StackManager's transition logic instead of being unmounted
+            // Special handling for Navigate components - they should unmount after redirecting
+            const elementComponent = (_c = (_b = viewItem.reactElement) === null || _b === void 0 ? void 0 : _b.props) === null || _c === void 0 ? void 0 : _c.element;
+            const isNavigateComponent = isNavigateElement(elementComponent);
+            if (isNavigateComponent) {
+                // Navigate components should only be mounted when they match
+                // Once they redirect (no longer match), they should be removed completely
+                // IMPORTANT: For index routes, we need to check indexMatch too since matchComponent
+                // may not properly match index routes without explicit parent path context
+                const indexMatch = ((_e = (_d = viewItem.routeData) === null || _d === void 0 ? void 0 : _d.childProps) === null || _e === void 0 ? void 0 : _e.index)
+                    ? resolveIndexRouteMatch(viewItem, routeInfo.pathname, parentPath)
+                    : null;
+                const hasValidMatch = match || indexMatch;
+                if (!hasValidMatch && viewItem.mount) {
                     viewItem.mount = false;
+                    // Schedule removal of the Navigate view item after a short delay
+                    // This ensures the redirect completes before removal
+                    setTimeout(() => {
+                        this.remove(viewItem);
+                    }, NAVIGATE_REDIRECT_DELAY_MS);
                 }
             }
-            return clonedChild;
-        });
-        return children;
-    }
-    findViewItemByRouteInfo(routeInfo, outletId, updateMatch) {
-        const { viewItem, match } = this.findViewItemByPath(routeInfo.pathname, outletId);
-        const shouldUpdateMatch = updateMatch === undefined || updateMatch === true;
-        if (shouldUpdateMatch && viewItem && match) {
-            viewItem.routeData.match = match;
-        }
-        return viewItem;
-    }
-    findLeavingViewItemByRouteInfo(routeInfo, outletId, mustBeIonRoute = true) {
-        const { viewItem } = this.findViewItemByPath(routeInfo.lastPathname, outletId, mustBeIonRoute);
-        return viewItem;
-    }
-    findViewItemByPathname(pathname, outletId) {
-        const { viewItem } = this.findViewItemByPath(pathname, outletId);
-        return viewItem;
+            // Components that don't have IonPage elements and no longer match should be cleaned up
+            // BUT we need to be careful not to remove them if they're part of browser navigation history
+            // This handles components that perform immediate actions like programmatic navigation
+            // EXCEPTION: Navigate components should ALWAYS remain mounted until they redirect
+            // since they need to be rendered to trigger the navigation
+            if (!match && viewItem.mount && !viewItem.ionPageElement && !isNavigateComponent) {
+                // Check if this view item should be preserved for browser navigation
+                // We'll keep it if it was recently active (within the last navigation)
+                const shouldPreserve = viewItem.routeData.lastPathname === routeInfo.pathname ||
+                    ((_f = viewItem.routeData.match) === null || _f === void 0 ? void 0 : _f.pathname) === routeInfo.lastPathname;
+                if (!shouldPreserve) {
+                    // This view item doesn't match and doesn't have an IonPage
+                    // It's likely a utility component that performs an action and navigates away
+                    viewItem.mount = false;
+                    // Schedule removal to allow it to be recreated on next navigation
+                    setTimeout(() => {
+                        // Double-check before removing - the view might be needed again
+                        const stillNotNeeded = !viewItem.mount && !viewItem.ionPageElement;
+                        if (stillNotNeeded) {
+                            this.remove(viewItem);
+                        }
+                    }, VIEW_CLEANUP_DELAY_MS);
+                }
+                else {
+                    // Preserve it but unmount it for now
+                    viewItem.mount = false;
+                }
+            }
+            // Reactivate view if it matches but was previously deactivated
+            // Don't reactivate if this is a parameterized route navigating to a different path instance
+            if (match && !viewItem.mount && !shouldSkipForDifferentParam) {
+                viewItem.mount = true;
+                viewItem.routeData.match = match;
+            }
+            // Deactivate wildcard routes and catch-all routes (empty path) when we have specific route matches
+            // This prevents "Not found" or fallback pages from showing alongside valid routes
+            if (routePath === '*' || routePath === '') {
+                // Check if any other view in this outlet has a match for the current route
+                const hasSpecificMatch = this.getViewItemsForOutlet(viewItem.outletId).some((v) => {
+                    var _a, _b;
+                    if (v.id === viewItem.id)
+                        return false; // Skip self
+                    const vRoutePath = ((_b = (_a = v.reactElement) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.path) || '';
+                    if (vRoutePath === '*' || vRoutePath === '')
+                        return false; // Skip other wildcard/empty routes
+                    // Check if this view item would match the current route
+                    const vMatch = v.reactElement ? matchComponent$1(v.reactElement, routeInfo.pathname) : null;
+                    return !!vMatch;
+                });
+                if (hasSpecificMatch) {
+                    viewItem.mount = false;
+                    if (viewItem.ionPageElement) {
+                        viewItem.ionPageElement.classList.add('ion-page-hidden');
+                        viewItem.ionPageElement.setAttribute('aria-hidden', 'true');
+                    }
+                }
+            }
+            const routeElement = React.cloneElement(viewItem.reactElement);
+            const componentElement = routeElement.props.element;
+            // Don't update match for parameterized routes navigating to different path instances
+            // This preserves the original match so that findViewItemByPath can correctly skip this view
+            if (match && viewItem.routeData.match !== match && !shouldSkipForDifferentParam) {
+                viewItem.routeData.match = match;
+            }
+            const routeMatch = shouldSkipForDifferentParam ? (_g = viewItem.routeData) === null || _g === void 0 ? void 0 : _g.match : match || ((_h = viewItem.routeData) === null || _h === void 0 ? void 0 : _h.match);
+            return (React.createElement(UNSAFE_RouteContext.Consumer, { key: `view-context-${viewItem.id}` }, (parentContext) => {
+                var _a, _b;
+                const parentMatches = ((_a = parentContext === null || parentContext === void 0 ? void 0 : parentContext.matches) !== null && _a !== void 0 ? _a : []);
+                // Accumulate params from parent matches, with fallback to other outlets
+                let accumulatedParentParams = parentMatches.reduce((acc, m) => (Object.assign(Object.assign({}, acc), m.params)), {});
+                if (parentMatches.length === 0 && Object.keys(accumulatedParentParams).length === 0) {
+                    accumulatedParentParams = getFallbackParamsFromViewItems(this.getAllViewItems(), viewItem.outletId, routeInfo.pathname);
+                }
+                const combinedParams = Object.assign(Object.assign({}, accumulatedParentParams), ((_b = routeMatch === null || routeMatch === void 0 ? void 0 : routeMatch.params) !== null && _b !== void 0 ? _b : {}));
+                const parentPathnameBase = parentMatches.length > 0 ? parentMatches[parentMatches.length - 1].pathnameBase : '/';
+                const absolutePathnameBase = computeAbsolutePathnameBase(routeElement, routeMatch, parentPathnameBase, routeInfo.pathname);
+                const contextMatches = buildContextMatches(parentMatches, combinedParams, routeMatch, routeInfo.pathname, absolutePathnameBase, viewItem, routeElement, componentElement);
+                const routeContextValue = parentContext
+                    ? Object.assign(Object.assign({}, parentContext), { matches: contextMatches }) : { outlet: null, matches: contextMatches, isDataRoute: false };
+                return (React.createElement(ViewLifeCycleManager, { key: `view-${viewItem.id}`, mount: viewItem.mount, removeView: () => this.remove(viewItem) },
+                    React.createElement(UNSAFE_RouteContext.Provider, { value: routeContextValue }, componentElement)));
+            }));
+        };
+        /**
+         * Re-renders all active view items for the specified outlet.
+         * Ensures React elements are updated with the latest match.
+         *
+         * 1. Iterates through children of IonRouterOutlet
+         * 2. Updates each matching viewItem with the current child React element
+         *    (important for updating props or changes to elements)
+         * 3. Returns a list of React components that will be rendered inside the outlet
+         *    Each view is wrapped in <ViewLifeCycleManager> to manage lifecycle and rendering
+         */
+        this.getChildrenToRender = (outletId, ionRouterOutlet, routeInfo) => {
+            const viewItems = this.getViewItemsForOutlet(outletId);
+            // Determine parentPath for nested outlets to properly evaluate index routes
+            let parentPath = undefined;
+            try {
+                // Only attempt parent path computation for non-root outlets
+                // Root outlets have IDs like 'routerOutlet' or 'routerOutlet-2'
+                const isRootOutlet = outletId.startsWith('routerOutlet');
+                if (!isRootOutlet) {
+                    const routeChildren = extractRouteChildren(ionRouterOutlet.props.children);
+                    const { hasRelativeRoutes, hasIndexRoute, hasWildcardRoute } = analyzeRouteChildren(routeChildren);
+                    if (hasRelativeRoutes || hasIndexRoute) {
+                        const result = computeParentPath({
+                            currentPathname: routeInfo.pathname,
+                            outletMountPath: undefined,
+                            routeChildren,
+                            hasRelativeRoutes,
+                            hasIndexRoute,
+                            hasWildcardRoute,
+                        });
+                        parentPath = result.parentPath;
+                    }
+                }
+            }
+            catch (e) {
+                // Non-fatal: if we fail to compute parentPath, fall back to previous behavior
+            }
+            // Sync child elements with stored viewItems (e.g. to reflect new props)
+            React.Children.forEach(ionRouterOutlet.props.children, (child) => {
+                // Ensure the child is a valid React element since we
+                // might have whitespace strings or other non-element children
+                if (React.isValidElement(child)) {
+                    // Find view item by exact path match to avoid wildcard routes overwriting specific routes
+                    const childPath = child.props.path;
+                    const viewItem = viewItems.find((v) => {
+                        var _a, _b;
+                        const viewItemPath = (_b = (_a = v.reactElement) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.path;
+                        // Only update if paths match exactly (prevents wildcard routes from overwriting specific routes)
+                        return viewItemPath === childPath;
+                    });
+                    if (viewItem) {
+                        viewItem.reactElement = child;
+                    }
+                }
+            });
+            // Filter out duplicate view items by ID (but keep all mounted items)
+            const uniqueViewItems = viewItems.filter((viewItem, index, array) => {
+                // Remove duplicates by ID (keep first occurrence)
+                const isFirstOccurrence = array.findIndex((v) => v.id === viewItem.id) === index;
+                return isFirstOccurrence;
+            });
+            // Filter out unmounted Navigate components to prevent them from being rendered
+            // and triggering unwanted redirects
+            const renderableViewItems = uniqueViewItems.filter((viewItem) => {
+                var _a, _b, _c, _d;
+                const elementComponent = (_b = (_a = viewItem.reactElement) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.element;
+                const isNavigateComponent = isNavigateElement(elementComponent);
+                // Exclude unmounted Navigate components from rendering
+                if (isNavigateComponent && !viewItem.mount) {
+                    return false;
+                }
+                // Filter out views that are unmounted, have no ionPageElement, and don't match the current route.
+                // These are "stale" views from previous routes that should not be rendered.
+                // Views WITH ionPageElement are handled by the normal lifecycle events.
+                // Views that MATCH the current route should be kept (they might be transitioning).
+                if (!viewItem.mount && !viewItem.ionPageElement) {
+                    // Check if this view's route path matches the current pathname
+                    const viewRoutePath = (_d = (_c = viewItem.reactElement) === null || _c === void 0 ? void 0 : _c.props) === null || _d === void 0 ? void 0 : _d.path;
+                    if (viewRoutePath) {
+                        // First try exact match using matchComponent
+                        const routeMatch = matchComponent$1(viewItem.reactElement, routeInfo.pathname);
+                        if (routeMatch) {
+                            // View matches current route, keep it
+                            return true;
+                        }
+                        // For parent routes (like /multiple-tabs or /routing), check if current pathname
+                        // starts with this route's path. This handles views with IonSplitPane/IonTabs
+                        // that don't have IonPage but should remain mounted while navigating within their children.
+                        const normalizedViewPath = normalizePathnameForComparison(viewRoutePath.replace(/\/?\*$/, '')); // Remove trailing wildcard
+                        const normalizedCurrentPath = normalizePathnameForComparison(routeInfo.pathname);
+                        // Check if current pathname is within this view's route hierarchy
+                        const isWithinRouteHierarchy = normalizedCurrentPath === normalizedViewPath || normalizedCurrentPath.startsWith(normalizedViewPath + '/');
+                        if (!isWithinRouteHierarchy) {
+                            // View is outside current route hierarchy, remove it
+                            setTimeout(() => {
+                                this.remove(viewItem);
+                            }, 0);
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            });
+            const renderedItems = renderableViewItems.map((viewItem) => this.renderViewItem(viewItem, routeInfo, parentPath));
+            return renderedItems;
+        };
+        /**
+         * Finds a view item matching the current route, optionally updating its match state.
+         */
+        this.findViewItemByRouteInfo = (routeInfo, outletId, updateMatch) => {
+            const { viewItem, match } = this.findViewItemByPath(routeInfo.pathname, outletId);
+            const shouldUpdateMatch = updateMatch === undefined || updateMatch === true;
+            if (shouldUpdateMatch && viewItem && match) {
+                viewItem.routeData.match = match;
+            }
+            return viewItem;
+        };
+        /**
+         * Finds the view item that was previously active before a route change.
+         */
+        this.findLeavingViewItemByRouteInfo = (routeInfo, outletId, mustBeIonRoute = true) => {
+            // If the lastPathname is not set, we cannot find a leaving view item
+            if (!routeInfo.lastPathname) {
+                return undefined;
+            }
+            const { viewItem } = this.findViewItemByPath(routeInfo.lastPathname, outletId, mustBeIonRoute);
+            return viewItem;
+        };
+        /**
+         * Finds a view item by pathname only, used in simpler queries.
+         */
+        this.findViewItemByPathname = (pathname, outletId) => {
+            const { viewItem } = this.findViewItemByPath(pathname, outletId);
+            return viewItem;
+        };
+        /**
+         * Clean up old, unmounted view items to prevent memory leaks
+         */
+        this.cleanupStaleViewItems = (outletId) => {
+            const viewItems = this.getViewItemsForOutlet(outletId);
+            // Keep only the most recent mounted views and a few unmounted ones for history
+            const maxUnmountedItems = 3;
+            const unmountedItems = viewItems.filter((v) => !v.mount);
+            if (unmountedItems.length > maxUnmountedItems) {
+                // Remove oldest unmounted items
+                const itemsToRemove = unmountedItems.slice(0, unmountedItems.length - maxUnmountedItems);
+                itemsToRemove.forEach((item) => {
+                    this.remove(item);
+                });
+            }
+        };
+        /**
+         * Override add to prevent duplicate view items with the same ID in the same outlet
+         * But allow multiple view items for the same route path (for navigation history)
+         */
+        this.add = (viewItem) => {
+            const existingViewItem = this.getViewItemsForOutlet(viewItem.outletId).find((v) => v.id === viewItem.id);
+            if (existingViewItem) {
+                return;
+            }
+            super.add(viewItem);
+            this.cleanupStaleViewItems(viewItem.outletId);
+        };
+        /**
+         * Override remove
+         */
+        this.remove = (viewItem) => {
+            super.remove(viewItem);
+        };
     }
     /**
-     * Returns the matching view item and the match result for a given pathname.
+     * Core function that matches a given pathname against all view items.
+     * Returns both the matched view item and match metadata.
      */
-    findViewItemByPath(pathname, outletId, mustBeIonRoute) {
+    findViewItemByPath(pathname, outletId, mustBeIonRoute, allowDefaultMatch = true) {
         let viewItem;
-        let match;
+        let match = null;
         let viewStack;
         if (outletId) {
-            viewStack = this.getViewItemsForOutlet(outletId);
+            viewStack = sortViewsBySpecificity(this.getViewItemsForOutlet(outletId));
             viewStack.some(matchView);
-            if (!viewItem) {
+            if (!viewItem && allowDefaultMatch)
                 viewStack.some(matchDefaultRoute);
-            }
         }
         else {
-            const viewItems = this.getAllViewItems();
+            const viewItems = sortViewsBySpecificity(this.getAllViewItems());
             viewItems.some(matchView);
-            if (!viewItem) {
+            if (!viewItem && allowDefaultMatch)
                 viewItems.some(matchDefaultRoute);
-            }
         }
+        // If we still have not found a view item for this outlet, try to find a matching
+        // view item across all outlets and adopt it into the current outlet. This helps
+        // recover when an outlet remounts and receives a new id, leaving views associated
+        // with the previous outlet id.
+        // Do not adopt across outlets; if we didn't find a view for this outlet,
+        // defer to route matching to create a new one.
         return { viewItem, match };
+        /**
+         * Matches a route path with dynamic parameters (e.g. /tabs/:id)
+         */
         function matchView(v) {
-            var _a, _b;
-            if (mustBeIonRoute && !v.ionRoute) {
+            var _a;
+            if (mustBeIonRoute && !v.ionRoute)
                 return false;
+            const viewItemPath = v.routeData.childProps.path || '';
+            const isIndexRoute = !!v.routeData.childProps.index;
+            const previousMatch = (_a = v.routeData) === null || _a === void 0 ? void 0 : _a.match;
+            const result = v.reactElement ? matchComponent$1(v.reactElement, pathname) : null;
+            if (!result) {
+                const indexMatch = resolveIndexRouteMatch(v, pathname, undefined);
+                if (indexMatch) {
+                    match = indexMatch;
+                    viewItem = v;
+                    return true;
+                }
             }
-            match = matchPath({
-                pathname,
-                componentProps: v.routeData.childProps,
-            });
-            if (match) {
-                /**
-                 * Even though we have a match from react-router, we do not know if the match
-                 * is for this specific view item.
-                 *
-                 * To validate this, we need to check if the path and url match the view item's route data.
-                 */
-                const hasParameter = match.path.includes(':');
-                if (!hasParameter || (hasParameter && match.url === ((_b = (_a = v.routeData) === null || _a === void 0 ? void 0 : _a.match) === null || _b === void 0 ? void 0 : _b.url))) {
+            if (result) {
+                const hasParams = result.params && Object.keys(result.params).length > 0;
+                const isSamePath = result.pathname === (previousMatch === null || previousMatch === void 0 ? void 0 : previousMatch.pathname);
+                const isWildcardRoute = viewItemPath.includes('*');
+                const isParameterRoute = viewItemPath.includes(':');
+                // Don't allow view items with undefined paths to match specific routes
+                // This prevents broken index route view items from interfering with navigation
+                if (!viewItemPath && !isIndexRoute && pathname !== '/' && pathname !== '') {
+                    return false;
+                }
+                // For parameterized routes, check if we should reuse the view item.
+                // Wildcard routes (e.g., user/:userId/*) compare pathnameBase to allow
+                // child path changes while preserving the parent view.
+                if (isParameterRoute && !isSamePath) {
+                    if (isWildcardRoute) {
+                        const isSameBase = result.pathnameBase === (previousMatch === null || previousMatch === void 0 ? void 0 : previousMatch.pathnameBase);
+                        if (isSameBase) {
+                            match = result;
+                            viewItem = v;
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+                // For routes without params, or when navigating to the exact same path,
+                // or when there's no previous match, reuse the view item
+                if (!hasParams || isSamePath || !previousMatch) {
+                    match = result;
                     viewItem = v;
                     return true;
                 }
+                // For pure wildcard routes (without : params), compare pathnameBase to allow
+                // child path changes while preserving the parent view. This handles container
+                // routes like /tabs/* where switching between /tabs/tab1 and /tabs/tab2
+                // should reuse the same ViewItem.
+                if (isWildcardRoute && !isParameterRoute) {
+                    const isSameBase = result.pathnameBase === (previousMatch === null || previousMatch === void 0 ? void 0 : previousMatch.pathnameBase);
+                    if (isSameBase) {
+                        match = result;
+                        viewItem = v;
+                        return true;
+                    }
+                }
             }
             return false;
         }
+        /**
+         * Matches a view with no path prop (default fallback route) or index route.
+         */
         function matchDefaultRoute(v) {
-            // try to find a route that doesn't have a path or from prop, that will be our default route
-            if (!v.routeData.childProps.path && !v.routeData.childProps.from) {
+            var _a, _b, _c;
+            const childProps = v.routeData.childProps;
+            const isDefaultRoute = childProps.path === undefined || childProps.path === '';
+            const isIndexRoute = !!childProps.index;
+            if (isIndexRoute) {
+                const indexMatch = resolveIndexRouteMatch(v, pathname, undefined);
+                if (indexMatch) {
+                    match = indexMatch;
+                    viewItem = v;
+                    return true;
+                }
+                return false;
+            }
+            // For empty path routes, only match if we're at the same level as when the view was created.
+            // This prevents an empty path view item from being reused for different routes.
+            if (isDefaultRoute) {
+                const previousPathnameBase = ((_b = (_a = v.routeData) === null || _a === void 0 ? void 0 : _a.match) === null || _b === void 0 ? void 0 : _b.pathnameBase) || '';
+                const normalizedBase = normalizePathnameForComparison(previousPathnameBase);
+                const normalizedPathname = normalizePathnameForComparison(pathname);
+                if (normalizedPathname !== normalizedBase) {
+                    return false;
+                }
                 match = {
-                    path: pathname,
-                    url: pathname,
-                    isExact: true,
                     params: {},
+                    pathname,
+                    pathnameBase: pathname === '' ? '/' : pathname,
+                    pattern: {
+                        path: '',
+                        caseSensitive: (_c = childProps.caseSensitive) !== null && _c !== void 0 ? _c : false,
+                        end: true,
+                    },
                 };
                 viewItem = v;
                 return true;
@@ -179,11 +1133,29 @@ class ReactRouterViewStack extends ViewStacks {
         }
     }
 }
-function matchComponent$1(node, pathname) {
-    return matchPath({
-        pathname,
-        componentProps: node.props,
+/**
+ * Utility to apply matchPath to a React element and return its match state.
+ */
+function matchComponent$1(node, pathname, allowFallback = false) {
+    var _a;
+    const routeProps = (_a = node === null || node === void 0 ? void 0 : node.props) !== null && _a !== void 0 ? _a : {};
+    const routePath = routeProps.path;
+    const pathnameToMatch = derivePathnameToMatch(pathname, routePath);
+    const match = matchPath({
+        pathname: pathnameToMatch,
+        componentProps: routeProps,
     });
+    if (match || !allowFallback) {
+        return match;
+    }
+    const isIndexRoute = !!routeProps.index;
+    if (isIndexRoute) {
+        return createDefaultMatch(pathname, routeProps);
+    }
+    if (!routePath || routePath === '') {
+        return createDefaultMatch(pathname, routeProps);
+    }
+    return null;
 }
 
 function clonePageElement(leavingViewHtml) {
@@ -208,7 +1180,35 @@ function clonePageElement(leavingViewHtml) {
     return undefined;
 }
 
-const isViewVisible = (el) => !el.classList.contains('ion-page-invisible') && !el.classList.contains('ion-page-hidden');
+/**
+ * `StackManager` is responsible for managing page transitions, keeping track
+ * of views (pages), and ensuring that navigation behaves like native apps —
+ * particularly with animations and swipe gestures.
+ */
+/**
+ * Delay in milliseconds before unmounting a view after a transition completes.
+ * This ensures the page transition animation finishes before the view is removed.
+ */
+const VIEW_UNMOUNT_DELAY_MS = 250;
+/**
+ * Delay in milliseconds to wait for an IonPage element to be mounted before
+ * proceeding with a page transition.
+ */
+const ION_PAGE_WAIT_TIMEOUT_MS = 50;
+const isViewVisible = (el) => !el.classList.contains('ion-page-invisible') && !el.classList.contains('ion-page-hidden') && el.style.display !== 'none';
+const hideIonPageElement = (element) => {
+    if (element) {
+        element.classList.add('ion-page-hidden');
+        element.setAttribute('aria-hidden', 'true');
+    }
+};
+const showIonPageElement = (element) => {
+    if (element) {
+        element.style.removeProperty('display');
+        element.classList.remove('ion-page-hidden');
+        element.removeAttribute('aria-hidden');
+    }
+};
 class StackManager extends React.PureComponent {
     constructor(props) {
         super(props);
@@ -217,13 +1217,479 @@ class StackManager extends React.PureComponent {
             isInOutlet: () => true,
         };
         this.pendingPageTransition = false;
+        this.waitingForIonPage = false;
+        this.outletMountPath = undefined;
         this.registerIonPage = this.registerIonPage.bind(this);
         this.transitionPage = this.transitionPage.bind(this);
         this.handlePageTransition = this.handlePageTransition.bind(this);
-        this.id = generateId('routerOutlet');
+        this.id = props.id || `routerOutlet-${generateId('routerOutlet')}`;
         this.prevProps = undefined;
         this.skipTransition = false;
     }
+    /**
+     * Determines the parent path for nested routing in React Router 6.
+     * Priority: specific routes > wildcard routes > index routes (only at mount point)
+     */
+    getParentPath() {
+        const currentPathname = this.props.routeInfo.pathname;
+        // Prevent out-of-scope outlets from adopting unrelated routes
+        if (this.outletMountPath && !currentPathname.startsWith(this.outletMountPath)) {
+            return undefined;
+        }
+        if (this.ionRouterOutlet) {
+            const routeChildren = extractRouteChildren(this.ionRouterOutlet.props.children);
+            const { hasRelativeRoutes, hasIndexRoute, hasWildcardRoute } = analyzeRouteChildren(routeChildren);
+            const isRootOutlet = this.id.startsWith('routerOutlet');
+            const needsParentPath = !isRootOutlet || hasRelativeRoutes || hasIndexRoute;
+            if (needsParentPath) {
+                const result = computeParentPath({
+                    currentPathname,
+                    outletMountPath: this.outletMountPath,
+                    routeChildren,
+                    hasRelativeRoutes,
+                    hasIndexRoute,
+                    hasWildcardRoute,
+                });
+                if (result.outletMountPath && !this.outletMountPath) {
+                    this.outletMountPath = result.outletMountPath;
+                }
+                return result.parentPath;
+            }
+        }
+        return this.outletMountPath;
+    }
+    /**
+     * Finds the entering and leaving view items, handling redirect cases.
+     */
+    findViewItems(routeInfo) {
+        const enteringViewItem = this.context.findViewItemByRouteInfo(routeInfo, this.id);
+        let leavingViewItem = this.context.findLeavingViewItemByRouteInfo(routeInfo, this.id);
+        // Try to find leaving view by previous pathname
+        if (!leavingViewItem && routeInfo.prevRouteLastPathname) {
+            leavingViewItem = this.context.findViewItemByPathname(routeInfo.prevRouteLastPathname, this.id);
+        }
+        // For redirects where entering === leaving, find the actual previous view
+        if (enteringViewItem &&
+            leavingViewItem &&
+            enteringViewItem === leavingViewItem &&
+            routeInfo.routeAction === 'replace' &&
+            routeInfo.prevRouteLastPathname) {
+            const actualLeavingView = this.context.findViewItemByPathname(routeInfo.prevRouteLastPathname, this.id);
+            if (actualLeavingView && actualLeavingView !== enteringViewItem) {
+                leavingViewItem = actualLeavingView;
+            }
+        }
+        // Handle redirect scenario with no leaving view
+        if (enteringViewItem &&
+            !leavingViewItem &&
+            routeInfo.routeAction === 'replace' &&
+            routeInfo.prevRouteLastPathname) {
+            const actualLeavingView = this.context.findViewItemByPathname(routeInfo.prevRouteLastPathname, this.id);
+            if (actualLeavingView && actualLeavingView !== enteringViewItem) {
+                leavingViewItem = actualLeavingView;
+            }
+        }
+        return { enteringViewItem, leavingViewItem };
+    }
+    shouldUnmountLeavingView(routeInfo, enteringViewItem, leavingViewItem) {
+        var _a, _b, _c, _d;
+        if (!leavingViewItem) {
+            return false;
+        }
+        if (routeInfo.routeAction === 'replace') {
+            const enteringRoutePath = (_b = (_a = enteringViewItem === null || enteringViewItem === void 0 ? void 0 : enteringViewItem.reactElement) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.path;
+            const leavingRoutePath = (_d = (_c = leavingViewItem === null || leavingViewItem === void 0 ? void 0 : leavingViewItem.reactElement) === null || _c === void 0 ? void 0 : _c.props) === null || _d === void 0 ? void 0 : _d.path;
+            // Never unmount root path - needed for back navigation
+            if (leavingRoutePath === '/' || leavingRoutePath === '') {
+                return false;
+            }
+            if (enteringRoutePath && leavingRoutePath) {
+                const getParentPath = (path) => {
+                    const normalized = path.replace(/\/\*$/, '');
+                    const lastSlash = normalized.lastIndexOf('/');
+                    return lastSlash > 0 ? normalized.substring(0, lastSlash) : '/';
+                };
+                const enteringParent = getParentPath(enteringRoutePath);
+                const leavingParent = getParentPath(leavingRoutePath);
+                // Unmount if routes are siblings or entering is a child of leaving (redirect)
+                const areSiblings = enteringParent === leavingParent && enteringParent !== '/';
+                const isChildRedirect = enteringRoutePath.startsWith(leavingRoutePath) ||
+                    (leavingRoutePath.endsWith('/*') && enteringRoutePath.startsWith(leavingRoutePath.slice(0, -2)));
+                return areSiblings || isChildRedirect;
+            }
+            return false;
+        }
+        // For non-replace actions, only unmount for back navigation
+        const isForwardPush = routeInfo.routeAction === 'push' && routeInfo.routeDirection === 'forward';
+        if (!isForwardPush && routeInfo.routeDirection !== 'none' && enteringViewItem !== leavingViewItem) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Handles out-of-scope outlet. Returns true if transition should be aborted.
+     */
+    handleOutOfScopeOutlet(routeInfo) {
+        if (!this.outletMountPath || routeInfo.pathname.startsWith(this.outletMountPath)) {
+            return false;
+        }
+        if (this.outOfScopeUnmountTimeout) {
+            clearTimeout(this.outOfScopeUnmountTimeout);
+            this.outOfScopeUnmountTimeout = undefined;
+        }
+        const allViewsInOutlet = this.context.getViewItemsForOutlet(this.id);
+        allViewsInOutlet.forEach((viewItem) => {
+            hideIonPageElement(viewItem.ionPageElement);
+            this.context.unMountViewItem(viewItem);
+        });
+        this.forceUpdate();
+        return true;
+    }
+    /**
+     * Handles nested outlet with relative routes but no parent path. Returns true to abort.
+     */
+    handleOutOfContextNestedOutlet(parentPath, leavingViewItem) {
+        var _a;
+        const isRootOutlet = this.id.startsWith('routerOutlet');
+        if (isRootOutlet || parentPath !== undefined || !this.ionRouterOutlet) {
+            return false;
+        }
+        const routesChildren = (_a = getRoutesChildren(this.ionRouterOutlet.props.children)) !== null && _a !== void 0 ? _a : this.ionRouterOutlet.props.children;
+        const routeChildren = React.Children.toArray(routesChildren).filter((child) => React.isValidElement(child) && child.type === Route);
+        const hasRelativeRoutes = routeChildren.some((route) => {
+            const path = route.props.path;
+            return path && !path.startsWith('/') && path !== '*';
+        });
+        if (hasRelativeRoutes) {
+            hideIonPageElement(leavingViewItem === null || leavingViewItem === void 0 ? void 0 : leavingViewItem.ionPageElement);
+            if (leavingViewItem) {
+                leavingViewItem.mount = false;
+            }
+            this.forceUpdate();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Handles nested outlet with no matching route. Returns true to abort.
+     */
+    handleNoMatchingRoute(enteringRoute, enteringViewItem, leavingViewItem) {
+        const isRootOutlet = this.id.startsWith('routerOutlet');
+        if (isRootOutlet || enteringRoute || enteringViewItem) {
+            return false;
+        }
+        hideIonPageElement(leavingViewItem === null || leavingViewItem === void 0 ? void 0 : leavingViewItem.ionPageElement);
+        if (leavingViewItem) {
+            leavingViewItem.mount = false;
+        }
+        this.forceUpdate();
+        return true;
+    }
+    /**
+     * Handles transition when entering view has ion-page element ready.
+     */
+    handleReadyEnteringView(routeInfo, enteringViewItem, leavingViewItem, shouldUnmountLeavingViewItem) {
+        var _a, _b;
+        const routePath = (_b = (_a = enteringViewItem.reactElement) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.path;
+        const isParameterizedRoute = routePath ? routePath.includes(':') : false;
+        const isWildcardContainerRoute = routePath ? routePath.endsWith('/*') : false;
+        // Handle same-view transitions (parameterized routes like /user/:id or container routes like /tabs/*)
+        // When entering === leaving, the view is already visible - skip transition to prevent flash
+        if (enteringViewItem === leavingViewItem) {
+            if (isParameterizedRoute || isWildcardContainerRoute) {
+                const updatedMatch = matchComponent(enteringViewItem.reactElement, routeInfo.pathname, true);
+                if (updatedMatch) {
+                    enteringViewItem.routeData.match = updatedMatch;
+                }
+                const enteringEl = enteringViewItem.ionPageElement;
+                if (enteringEl) {
+                    showIonPageElement(enteringEl);
+                    enteringEl.classList.remove('ion-page-invisible');
+                }
+                this.forceUpdate();
+                return;
+            }
+        }
+        // For wildcard container routes, check if we're navigating within the same container.
+        // If both the current pathname and the previous pathname match the same container route,
+        // skip the transition - the nested outlet will handle the actual page change.
+        // This handles cases where leavingViewItem lookup fails (e.g., no IonPage wrapper).
+        if (isWildcardContainerRoute && routeInfo.lastPathname) {
+            // routePath is guaranteed to exist since isWildcardContainerRoute checks routePath?.endsWith('/*')
+            const containerBase = routePath.replace(/\/\*$/, '');
+            const currentInContainer = routeInfo.pathname.startsWith(containerBase + '/') || routeInfo.pathname === containerBase;
+            const previousInContainer = routeInfo.lastPathname.startsWith(containerBase + '/') || routeInfo.lastPathname === containerBase;
+            if (currentInContainer && previousInContainer) {
+                const updatedMatch = matchComponent(enteringViewItem.reactElement, routeInfo.pathname, true);
+                if (updatedMatch) {
+                    enteringViewItem.routeData.match = updatedMatch;
+                }
+                this.forceUpdate();
+                return;
+            }
+        }
+        if (!leavingViewItem && this.props.routeInfo.prevRouteLastPathname) {
+            leavingViewItem = this.context.findViewItemByPathname(this.props.routeInfo.prevRouteLastPathname, this.id);
+        }
+        // Re-mount views that were previously unmounted (e.g., navigating back to home)
+        if (!enteringViewItem.mount) {
+            enteringViewItem.mount = true;
+        }
+        // Check visibility state BEFORE showing entering view
+        const enteringWasVisible = enteringViewItem.ionPageElement && isViewVisible(enteringViewItem.ionPageElement);
+        const leavingIsHidden = leavingViewItem !== undefined && leavingViewItem.ionPageElement && !isViewVisible(leavingViewItem.ionPageElement);
+        const currentTransition = {
+            enteringId: enteringViewItem.id,
+            leavingId: leavingViewItem === null || leavingViewItem === void 0 ? void 0 : leavingViewItem.id,
+        };
+        const isDuplicateTransition = leavingViewItem &&
+            this.lastTransition &&
+            this.lastTransition.leavingId &&
+            this.lastTransition.enteringId === currentTransition.enteringId &&
+            this.lastTransition.leavingId === currentTransition.leavingId;
+        // Skip if transition already performed (e.g., via swipe gesture)
+        if (enteringWasVisible && leavingIsHidden && isDuplicateTransition) {
+            if (this.skipTransition &&
+                shouldUnmountLeavingViewItem &&
+                leavingViewItem &&
+                enteringViewItem !== leavingViewItem) {
+                leavingViewItem.mount = false;
+                // Trigger ionViewDidLeave lifecycle for ViewLifeCycleManager cleanup
+                this.transitionPage(routeInfo, enteringViewItem, leavingViewItem, 'back');
+            }
+            this.skipTransition = false;
+            this.forceUpdate();
+            return;
+        }
+        showIonPageElement(enteringViewItem.ionPageElement);
+        // Handle duplicate transition or swipe gesture completion
+        if (isDuplicateTransition || this.skipTransition) {
+            if (this.skipTransition &&
+                shouldUnmountLeavingViewItem &&
+                leavingViewItem &&
+                enteringViewItem !== leavingViewItem) {
+                leavingViewItem.mount = false;
+                // Re-fire ionViewDidLeave since gesture completed before mount=false was set
+                this.transitionPage(routeInfo, enteringViewItem, leavingViewItem, 'back');
+            }
+            this.skipTransition = false;
+            this.forceUpdate();
+            return;
+        }
+        this.lastTransition = currentTransition;
+        const shouldSkipAnimation = this.applySkipAnimationIfNeeded(enteringViewItem, leavingViewItem);
+        this.transitionPage(routeInfo, enteringViewItem, leavingViewItem, undefined, false, shouldSkipAnimation);
+        if (shouldUnmountLeavingViewItem && leavingViewItem && enteringViewItem !== leavingViewItem) {
+            leavingViewItem.mount = false;
+            this.handleLeavingViewUnmount(routeInfo, enteringViewItem, leavingViewItem);
+        }
+        // Clean up orphaned sibling views after replace actions (redirects)
+        this.cleanupOrphanedSiblingViews(routeInfo, enteringViewItem, leavingViewItem);
+    }
+    /**
+     * Handles leaving view unmount for replace actions.
+     */
+    handleLeavingViewUnmount(routeInfo, enteringViewItem, leavingViewItem) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!leavingViewItem.ionPageElement) {
+            return;
+        }
+        // Only replace actions unmount views; push/pop cache for navigation history
+        if (routeInfo.routeAction !== 'replace') {
+            return;
+        }
+        const enteringRoutePath = (_b = (_a = enteringViewItem.reactElement) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.path;
+        const leavingRoutePath = (_d = (_c = leavingViewItem.reactElement) === null || _c === void 0 ? void 0 : _c.props) === null || _d === void 0 ? void 0 : _d.path;
+        const isEnteringContainerRoute = enteringRoutePath && enteringRoutePath.endsWith('/*');
+        const isLeavingSpecificRoute = leavingRoutePath &&
+            leavingRoutePath !== '' &&
+            leavingRoutePath !== '*' &&
+            !leavingRoutePath.endsWith('/*') &&
+            !((_f = (_e = leavingViewItem.reactElement) === null || _e === void 0 ? void 0 : _e.props) === null || _f === void 0 ? void 0 : _f.index);
+        // Skip removal for container-to-container transitions (e.g., /tabs/* → /settings/*).
+        // These routes manage their own nested outlets; unmounting would disrupt child views.
+        if (isEnteringContainerRoute && !isLeavingSpecificRoute) {
+            return;
+        }
+        const viewToUnmount = leavingViewItem;
+        setTimeout(() => {
+            this.context.unMountViewItem(viewToUnmount);
+            this.forceUpdate();
+        }, VIEW_UNMOUNT_DELAY_MS);
+    }
+    /**
+     * Cleans up orphaned sibling views after replace actions or push-to-container navigations.
+     */
+    cleanupOrphanedSiblingViews(routeInfo, enteringViewItem, leavingViewItem) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const enteringRoutePath = (_b = (_a = enteringViewItem.reactElement) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.path;
+        if (!enteringRoutePath) {
+            return;
+        }
+        const leavingRoutePath = (_d = (_c = leavingViewItem === null || leavingViewItem === void 0 ? void 0 : leavingViewItem.reactElement) === null || _c === void 0 ? void 0 : _c.props) === null || _d === void 0 ? void 0 : _d.path;
+        const isContainerRoute = (path) => path === null || path === void 0 ? void 0 : path.endsWith('/*');
+        const isReplaceAction = routeInfo.routeAction === 'replace';
+        const isPushToContainer = routeInfo.routeAction === 'push' && routeInfo.routeDirection === 'none' && isContainerRoute(enteringRoutePath);
+        if (!isReplaceAction && !isPushToContainer) {
+            return;
+        }
+        // Skip cleanup for tab switches
+        const isSameView = enteringViewItem === leavingViewItem;
+        const isSameContainerRoute = isContainerRoute(enteringRoutePath) && leavingRoutePath === enteringRoutePath;
+        const isNavigatingWithinContainer = isPushToContainer &&
+            !leavingViewItem &&
+            ((_e = routeInfo.prevRouteLastPathname) === null || _e === void 0 ? void 0 : _e.startsWith(enteringRoutePath.replace(/\/\*$/, '')));
+        if (isSameView || isSameContainerRoute || isNavigatingWithinContainer) {
+            return;
+        }
+        const allViewsInOutlet = this.context.getViewItemsForOutlet(this.id);
+        const areSiblingRoutes = (path1, path2) => {
+            const path1IsRelative = !path1.startsWith('/');
+            const path2IsRelative = !path2.startsWith('/');
+            if (path1IsRelative && path2IsRelative) {
+                const path1Depth = path1.replace(/\/\*$/, '').split('/').filter(Boolean).length;
+                const path2Depth = path2.replace(/\/\*$/, '').split('/').filter(Boolean).length;
+                return path1Depth === path2Depth && path1Depth <= 1;
+            }
+            const getParent = (path) => {
+                const normalized = path.replace(/\/\*$/, '');
+                const lastSlash = normalized.lastIndexOf('/');
+                return lastSlash > 0 ? normalized.substring(0, lastSlash) : '/';
+            };
+            return getParent(path1) === getParent(path2);
+        };
+        for (const viewItem of allViewsInOutlet) {
+            const viewRoutePath = (_g = (_f = viewItem.reactElement) === null || _f === void 0 ? void 0 : _f.props) === null || _g === void 0 ? void 0 : _g.path;
+            const shouldSkip = viewItem.id === enteringViewItem.id ||
+                (leavingViewItem && viewItem.id === leavingViewItem.id) ||
+                !viewItem.mount ||
+                !viewRoutePath ||
+                (viewRoutePath.endsWith('/*') && enteringRoutePath.endsWith('/*'));
+            if (shouldSkip) {
+                continue;
+            }
+            if (areSiblingRoutes(enteringRoutePath, viewRoutePath)) {
+                hideIonPageElement(viewItem.ionPageElement);
+                viewItem.mount = false;
+                const viewToRemove = viewItem;
+                setTimeout(() => {
+                    this.context.unMountViewItem(viewToRemove);
+                    this.forceUpdate();
+                }, VIEW_UNMOUNT_DELAY_MS);
+            }
+        }
+    }
+    /**
+     * Determines whether to skip the transition animation and, if so, immediately
+     * hides the leaving view with inline `display:none`.
+     *
+     * Skips transitions in outlets nested inside a parent IonPage. These outlets
+     * render pages inside a parent page's content area. The MD animation shows
+     * both entering and leaving pages simultaneously, causing text overlap and
+     * nested scrollbars (each page has its own IonContent). Top-level outlets
+     * are unaffected and animate normally.
+     *
+     * Uses inline display:none rather than ion-page-hidden class because core's
+     * beforeTransition() removes ion-page-hidden via setPageHidden().
+     * Inline display:none survives that removal, keeping the page hidden
+     * until React unmounts it after ionViewDidLeave fires.
+     */
+    applySkipAnimationIfNeeded(enteringViewItem, leavingViewItem) {
+        var _a;
+        const isNestedOutlet = !!((_a = this.routerOutletElement) === null || _a === void 0 ? void 0 : _a.closest('.ion-page'));
+        const shouldSkip = isNestedOutlet && !!leavingViewItem && enteringViewItem !== leavingViewItem;
+        if (shouldSkip && (leavingViewItem === null || leavingViewItem === void 0 ? void 0 : leavingViewItem.ionPageElement)) {
+            leavingViewItem.ionPageElement.style.setProperty('display', 'none');
+            leavingViewItem.ionPageElement.setAttribute('aria-hidden', 'true');
+        }
+        return shouldSkip;
+    }
+    /**
+     * Handles entering view with no ion-page element yet (waiting for render).
+     */
+    handleWaitingForIonPage(routeInfo, enteringViewItem, leavingViewItem, shouldUnmountLeavingViewItem) {
+        var _a, _b;
+        const enteringRouteElement = (_b = (_a = enteringViewItem.reactElement) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.element;
+        // Handle Navigate components (they never render an IonPage)
+        if (isNavigateElement(enteringRouteElement)) {
+            this.waitingForIonPage = false;
+            if (this.ionPageWaitTimeout) {
+                clearTimeout(this.ionPageWaitTimeout);
+                this.ionPageWaitTimeout = undefined;
+            }
+            this.pendingPageTransition = false;
+            // Hide ALL other visible views in this outlet for Navigate redirects.
+            // Same rationale as the timeout path: intermediate redirects can shift
+            // the leaving view reference, leaving the original page visible.
+            const allViewsInOutlet = this.context.getViewItemsForOutlet(this.id);
+            allViewsInOutlet.forEach((viewItem) => {
+                if (viewItem.id !== enteringViewItem.id && viewItem.ionPageElement) {
+                    hideIonPageElement(viewItem.ionPageElement);
+                }
+            });
+            // Don't unmount if entering and leaving are the same view item
+            if (shouldUnmountLeavingViewItem && leavingViewItem && enteringViewItem !== leavingViewItem) {
+                leavingViewItem.mount = false;
+            }
+            this.forceUpdate();
+            return;
+        }
+        // Do not hide the leaving view here - wait until the entering view is ready.
+        // Hiding the leaving view while the entering view is still mounting causes a flash
+        // where both views are hidden/invisible simultaneously.
+        // The leaving view will be hidden in transitionPage() after the entering view is visible.
+        this.waitingForIonPage = true;
+        if (this.ionPageWaitTimeout) {
+            clearTimeout(this.ionPageWaitTimeout);
+        }
+        this.ionPageWaitTimeout = setTimeout(() => {
+            var _a, _b;
+            this.ionPageWaitTimeout = undefined;
+            if (!this.waitingForIonPage) {
+                return;
+            }
+            this.waitingForIonPage = false;
+            const latestEnteringView = (_a = this.context.findViewItemByRouteInfo(routeInfo, this.id)) !== null && _a !== void 0 ? _a : enteringViewItem;
+            const latestLeavingView = (_b = this.context.findLeavingViewItemByRouteInfo(routeInfo, this.id)) !== null && _b !== void 0 ? _b : leavingViewItem;
+            if (latestEnteringView === null || latestEnteringView === void 0 ? void 0 : latestEnteringView.ionPageElement) {
+                const shouldSkipAnimation = this.applySkipAnimationIfNeeded(latestEnteringView, latestLeavingView !== null && latestLeavingView !== void 0 ? latestLeavingView : undefined);
+                this.transitionPage(routeInfo, latestEnteringView, latestLeavingView !== null && latestLeavingView !== void 0 ? latestLeavingView : undefined, undefined, false, shouldSkipAnimation);
+                if (shouldUnmountLeavingViewItem && latestLeavingView && latestEnteringView !== latestLeavingView) {
+                    latestLeavingView.mount = false;
+                    // Call handleLeavingViewUnmount to ensure the view is properly removed
+                    this.handleLeavingViewUnmount(routeInfo, latestEnteringView, latestLeavingView);
+                }
+                this.forceUpdate();
+            }
+            else {
+                /**
+                 * Timeout fired and entering view still has no ionPageElement.
+                 * This happens for container routes that render nested outlets without a direct IonPage.
+                 * Hide ALL other visible views in this outlet, not just the computed leaving view.
+                 * This handles cases where intermediate redirects (e.g., Navigate in nested routes)
+                 * change the leaving view reference, leaving the original page still visible.
+                 */
+                const allViewsInOutlet = this.context.getViewItemsForOutlet(this.id);
+                allViewsInOutlet.forEach((viewItem) => {
+                    if (viewItem.id !== latestEnteringView.id && viewItem.ionPageElement) {
+                        hideIonPageElement(viewItem.ionPageElement);
+                    }
+                });
+                this.forceUpdate();
+            }
+        }, ION_PAGE_WAIT_TIMEOUT_MS);
+        this.forceUpdate();
+    }
+    /**
+     * Gets the route info to use for finding views during swipe-to-go-back gestures.
+     * This pattern is used in multiple places in setupRouterOutlet.
+     */
+    getSwipeBackRouteInfo() {
+        const { routeInfo } = this.props;
+        return this.prevProps && this.prevProps.routeInfo.pathname === routeInfo.pushedByRoute
+            ? this.prevProps.routeInfo
+            : { pathname: routeInfo.pushedByRoute || '' };
+    }
     componentDidMount() {
         if (this.clearOutletTimeout) {
             /**
@@ -255,117 +1721,175 @@ class StackManager extends React.PureComponent {
         }
     }
     componentWillUnmount() {
+        if (this.ionPageWaitTimeout) {
+            clearTimeout(this.ionPageWaitTimeout);
+            this.ionPageWaitTimeout = undefined;
+        }
+        if (this.outOfScopeUnmountTimeout) {
+            clearTimeout(this.outOfScopeUnmountTimeout);
+            this.outOfScopeUnmountTimeout = undefined;
+        }
+        this.waitingForIonPage = false;
+        // Hide all views in this outlet before clearing.
+        // This is critical for nested outlets - when the parent component unmounts,
+        // the nested outlet's componentDidUpdate won't be called, so we must hide
+        // the ion-page elements here to prevent them from remaining visible on top
+        // of other content after navigation to a different route.
+        const allViewsInOutlet = this.context.getViewItemsForOutlet(this.id);
+        allViewsInOutlet.forEach((viewItem) => {
+            hideIonPageElement(viewItem.ionPageElement);
+        });
         this.clearOutletTimeout = this.context.clearOutlet(this.id);
     }
+    /**
+     * Sets the transition between pages within this router outlet.
+     * This function determines the entering and leaving views based on the
+     * provided route information and triggers the appropriate animation.
+     * It also handles scenarios like initial loads, back navigation, and
+     * navigation to the same view with different parameters.
+     *
+     * @param routeInfo It contains info about the current route,
+     * the previous route, and the action taken (e.g., push, replace).
+     *
+     * @returns A promise that resolves when the transition is complete.
+     * If no transition is needed or if the router outlet isn't ready,
+     * the Promise may resolve immediately.
+     */
     async handlePageTransition(routeInfo) {
-        var _a, _b;
+        var _a;
+        // Wait for router outlet to mount
         if (!this.routerOutletElement || !this.routerOutletElement.commit) {
-            /**
-             * The route outlet has not mounted yet. We need to wait for it to render
-             * before we can transition the page.
-             *
-             * Set a flag to indicate that we should transition the page after
-             * the component has updated.
-             */
             this.pendingPageTransition = true;
+            return;
         }
-        else {
-            let enteringViewItem = this.context.findViewItemByRouteInfo(routeInfo, this.id);
-            let leavingViewItem = this.context.findLeavingViewItemByRouteInfo(routeInfo, this.id);
-            if (!leavingViewItem && routeInfo.prevRouteLastPathname) {
-                leavingViewItem = this.context.findViewItemByPathname(routeInfo.prevRouteLastPathname, this.id);
-            }
-            // Check if leavingViewItem should be unmounted
-            if (leavingViewItem) {
-                if (routeInfo.routeAction === 'replace') {
-                    leavingViewItem.mount = false;
-                }
-                else if (!(routeInfo.routeAction === 'push' && routeInfo.routeDirection === 'forward')) {
-                    if (routeInfo.routeDirection !== 'none' && enteringViewItem !== leavingViewItem) {
-                        leavingViewItem.mount = false;
-                    }
-                }
-                else if ((_a = routeInfo.routeOptions) === null || _a === void 0 ? void 0 : _a.unmount) {
-                    leavingViewItem.mount = false;
-                }
+        // Find entering and leaving view items
+        const viewItems = this.findViewItems(routeInfo);
+        let enteringViewItem = viewItems.enteringViewItem;
+        const leavingViewItem = viewItems.leavingViewItem;
+        const shouldUnmountLeavingViewItem = this.shouldUnmountLeavingView(routeInfo, enteringViewItem, leavingViewItem);
+        // Get parent path for nested outlets
+        const parentPath = this.getParentPath();
+        // Handle out-of-scope outlet (route outside mount path)
+        if (this.handleOutOfScopeOutlet(routeInfo)) {
+            return;
+        }
+        // Clear any pending out-of-scope unmount timeout
+        if (this.outOfScopeUnmountTimeout) {
+            clearTimeout(this.outOfScopeUnmountTimeout);
+            this.outOfScopeUnmountTimeout = undefined;
+        }
+        // Handle nested outlet with relative routes but no valid parent path
+        if (this.handleOutOfContextNestedOutlet(parentPath, leavingViewItem)) {
+            return;
+        }
+        // Find the matching route element
+        const enteringRoute = findRouteByRouteInfo((_a = this.ionRouterOutlet) === null || _a === void 0 ? void 0 : _a.props.children, routeInfo, parentPath);
+        // Handle nested outlet with no matching route
+        if (this.handleNoMatchingRoute(enteringRoute, enteringViewItem, leavingViewItem)) {
+            return;
+        }
+        // Create or update the entering view item
+        if (enteringViewItem && enteringRoute) {
+            enteringViewItem.reactElement = enteringRoute;
+        }
+        else if (enteringRoute) {
+            enteringViewItem = this.context.createViewItem(this.id, enteringRoute, routeInfo);
+            this.context.addViewItem(enteringViewItem);
+        }
+        // Handle transition based on ion-page element availability
+        // Check if the ionPageElement is still in the document.
+        // If the view was previously unmounted (mount=false), the ViewLifeCycleManager
+        // removes the React component from the tree, which removes the IonPage from the DOM.
+        // The ionPageElement reference becomes stale and we need to wait for a new one.
+        const ionPageIsInDocument = (enteringViewItem === null || enteringViewItem === void 0 ? void 0 : enteringViewItem.ionPageElement) && document.body.contains(enteringViewItem.ionPageElement);
+        if (enteringViewItem && ionPageIsInDocument) {
+            // Clear waiting state
+            if (this.waitingForIonPage) {
+                this.waitingForIonPage = false;
             }
-            const enteringRoute = matchRoute((_b = this.ionRouterOutlet) === null || _b === void 0 ? void 0 : _b.props.children, routeInfo);
-            if (enteringViewItem) {
-                enteringViewItem.reactElement = enteringRoute;
+            if (this.ionPageWaitTimeout) {
+                clearTimeout(this.ionPageWaitTimeout);
+                this.ionPageWaitTimeout = undefined;
             }
-            else if (enteringRoute) {
-                enteringViewItem = this.context.createViewItem(this.id, enteringRoute, routeInfo);
-                this.context.addViewItem(enteringViewItem);
+            this.handleReadyEnteringView(routeInfo, enteringViewItem, leavingViewItem, shouldUnmountLeavingViewItem);
+        }
+        else if (enteringViewItem && !ionPageIsInDocument) {
+            // Wait for ion-page to mount
+            // This handles both: no ionPageElement, or stale ionPageElement (not in document)
+            // Clear stale reference if the element is no longer in the document
+            if (enteringViewItem.ionPageElement && !document.body.contains(enteringViewItem.ionPageElement)) {
+                enteringViewItem.ionPageElement = undefined;
             }
-            if (enteringViewItem && enteringViewItem.ionPageElement) {
-                /**
-                 * If the entering view item is the same as the leaving view item,
-                 * then we don't need to transition.
-                 */
-                if (enteringViewItem === leavingViewItem) {
-                    /**
-                     * If the entering view item is the same as the leaving view item,
-                     * we are either transitioning using parameterized routes to the same view
-                     * or a parent router outlet is re-rendering as a result of React props changing.
-                     *
-                     * If the route data does not match the current path, the parent router outlet
-                     * is attempting to transition and we cancel the operation.
-                     */
-                    if (enteringViewItem.routeData.match.url !== routeInfo.pathname) {
-                        return;
-                    }
-                }
-                /**
-                 * If there isn't a leaving view item, but the route info indicates
-                 * that the user has routed from a previous path, then we need
-                 * to find the leaving view item to transition between.
-                 */
-                if (!leavingViewItem && this.props.routeInfo.prevRouteLastPathname) {
-                    leavingViewItem = this.context.findViewItemByPathname(this.props.routeInfo.prevRouteLastPathname, this.id);
-                }
-                /**
-                 * If the entering view is already visible and the leaving view is not, the transition does not need to occur.
-                 */
-                if (isViewVisible(enteringViewItem.ionPageElement) &&
-                    leavingViewItem !== undefined &&
-                    !isViewVisible(leavingViewItem.ionPageElement)) {
-                    return;
-                }
-                /**
-                 * The view should only be transitioned in the following cases:
-                 * 1. Performing a replace or pop action, such as a swipe to go back gesture
-                 * to animation the leaving view off the screen.
-                 *
-                 * 2. Navigating between top-level router outlets, such as /page-1 to /page-2;
-                 * or navigating within a nested outlet, such as /tabs/tab-1 to /tabs/tab-2.
-                 *
-                 * 3. The entering view is an ion-router-outlet containing a page
-                 * matching the current route and that hasn't already transitioned in.
-                 *
-                 * This should only happen when navigating directly to a nested router outlet
-                 * route or on an initial page load (i.e. refreshing). In cases when loading
-                 * /tabs/tab-1, we need to transition the /tabs page element into the view.
-                 */
-                this.transitionPage(routeInfo, enteringViewItem, leavingViewItem);
+            // Ensure the view is marked as mounted so ViewLifeCycleManager renders the IonPage
+            if (!enteringViewItem.mount) {
+                enteringViewItem.mount = true;
             }
-            else if (leavingViewItem && !enteringRoute && !enteringViewItem) {
-                // If we have a leavingView but no entering view/route, we are probably leaving to
-                // another outlet, so hide this leavingView. We do it in a timeout to give time for a
-                // transition to finish.
-                // setTimeout(() => {
-                if (leavingViewItem.ionPageElement) {
-                    leavingViewItem.ionPageElement.classList.add('ion-page-hidden');
-                    leavingViewItem.ionPageElement.setAttribute('aria-hidden', 'true');
+            this.handleWaitingForIonPage(routeInfo, enteringViewItem, leavingViewItem, shouldUnmountLeavingViewItem);
+            return;
+        }
+        else if (!enteringViewItem && !enteringRoute) {
+            // No view or route found - likely leaving to another outlet
+            if (leavingViewItem) {
+                hideIonPageElement(leavingViewItem.ionPageElement);
+                if (shouldUnmountLeavingViewItem) {
+                    leavingViewItem.mount = false;
                 }
-                // }, 250);
             }
-            this.forceUpdate();
         }
+        this.forceUpdate();
     }
+    /**
+     * Registers an `<IonPage>` DOM element with the `StackManager`.
+     * This is called when `<IonPage>` has been mounted.
+     *
+     * @param page The element of the rendered `<IonPage>`.
+     * @param routeInfo The route information that associates with `<IonPage>`.
+     */
     registerIonPage(page, routeInfo) {
+        /**
+         * DO NOT remove ion-page-invisible here.
+         *
+         * PageManager's ref callback adds ion-page-invisible synchronously to prevent flash.
+         * At this point, the <IonPage> div exists but its CHILDREN (header, toolbar, menu-button)
+         * have NOT rendered yet. If we remove ion-page-invisible now, the page becomes visible
+         * with empty/incomplete content, causing a flicker (especially for ion-menu-button which
+         * starts with menu-button-hidden class).
+         *
+         * Instead, let transitionPage handle visibility AFTER waiting for components to be ready.
+         * This ensures the page only becomes visible when its content is fully rendered.
+         */
+        this.waitingForIonPage = false;
+        if (this.ionPageWaitTimeout) {
+            clearTimeout(this.ionPageWaitTimeout);
+            this.ionPageWaitTimeout = undefined;
+        }
+        this.pendingPageTransition = false;
         const foundView = this.context.findViewItemByRouteInfo(routeInfo, this.id);
         if (foundView) {
             const oldPageElement = foundView.ionPageElement;
+            /**
+             * FIX for issue #28878: Reject orphaned IonPage registrations.
+             *
+             * When a component conditionally renders different IonPages (e.g., list vs empty state)
+             * using React keys, and state changes simultaneously with navigation, the new IonPage
+             * tries to register for a route we're navigating away from. This creates a stale view.
+             *
+             * Only reject if both pageIds exist and differ, to allow nested outlet registrations.
+             */
+            if (this.shouldRejectOrphanedPage(page, oldPageElement, routeInfo)) {
+                this.hideAndRemoveOrphanedPage(page);
+                return;
+            }
+            /**
+             * Don't let a nested element (e.g., ion-router-outlet with ionPage prop)
+             * override an existing IonPage registration when the existing element is
+             * an ancestor of the new one. This ensures ionPageElement always points
+             * to the outermost IonPage, which is needed to properly hide the entire
+             * page during back navigation (not just the inner outlet).
+             */
+            if (oldPageElement && oldPageElement !== page && oldPageElement.isConnected && oldPageElement.contains(page)) {
+                return;
+            }
             foundView.ionPageElement = page;
             foundView.ionRoute = true;
             /**
@@ -379,6 +1903,32 @@ class StackManager extends React.PureComponent {
         }
         this.handlePageTransition(routeInfo);
     }
+    /**
+     * Checks if a new IonPage should be rejected (component re-rendered while navigating away).
+     */
+    shouldRejectOrphanedPage(newPage, oldPageElement, routeInfo) {
+        if (!oldPageElement || oldPageElement === newPage) {
+            return false;
+        }
+        const newPageId = newPage.getAttribute('data-pageid');
+        const oldPageId = oldPageElement.getAttribute('data-pageid');
+        if (!newPageId || !oldPageId || newPageId === oldPageId) {
+            return false;
+        }
+        return this.props.routeInfo.pathname !== routeInfo.pathname;
+    }
+    hideAndRemoveOrphanedPage(page) {
+        page.classList.add('ion-page-hidden');
+        page.setAttribute('aria-hidden', 'true');
+        setTimeout(() => {
+            if (page.parentElement) {
+                page.remove();
+            }
+        }, VIEW_UNMOUNT_DELAY_MS);
+    }
+    /**
+     * Configures swipe-to-go-back gesture for the router outlet.
+     */
     async setupRouterOutlet(routerOutlet) {
         const canStart = () => {
             const config = getConfig();
@@ -387,40 +1937,34 @@ class StackManager extends React.PureComponent {
                 return false;
             }
             const { routeInfo } = this.props;
-            const propsToUse = this.prevProps && this.prevProps.routeInfo.pathname === routeInfo.pushedByRoute
-                ? this.prevProps.routeInfo
-                : { pathname: routeInfo.pushedByRoute || '' };
-            const enteringViewItem = this.context.findViewItemByRouteInfo(propsToUse, this.id, false);
-            return (!!enteringViewItem &&
-                /**
-                 * The root url '/' is treated as
-                 * the first view item (but is never mounted),
-                 * so we do not want to swipe back to the
-                 * root url.
-                 */
-                enteringViewItem.mount &&
-                /**
-                 * When on the first page (whatever view
-                 * you land on after the root url) it
-                 * is possible for findViewItemByRouteInfo to
-                 * return the exact same view you are currently on.
-                 * Make sure that we are not swiping back to the same
-                 * instances of a view.
-                 */
-                enteringViewItem.routeData.match.path !== routeInfo.pathname);
+            const swipeBackRouteInfo = this.getSwipeBackRouteInfo();
+            let enteringViewItem = this.context.findViewItemByRouteInfo(swipeBackRouteInfo, this.id, false);
+            if (!enteringViewItem) {
+                enteringViewItem = this.context.findViewItemByRouteInfo(swipeBackRouteInfo, undefined, false);
+            }
+            // View might have mount=false but ionPageElement still in DOM
+            const ionPageInDocument = Boolean((enteringViewItem === null || enteringViewItem === void 0 ? void 0 : enteringViewItem.ionPageElement) && document.body.contains(enteringViewItem.ionPageElement));
+            const canStartSwipe = !!enteringViewItem &&
+                (enteringViewItem.mount || ionPageInDocument) &&
+                enteringViewItem.routeData.match.pattern.path !== routeInfo.pathname;
+            return canStartSwipe;
         };
         const onStart = async () => {
             const { routeInfo } = this.props;
-            const propsToUse = this.prevProps && this.prevProps.routeInfo.pathname === routeInfo.pushedByRoute
-                ? this.prevProps.routeInfo
-                : { pathname: routeInfo.pushedByRoute || '' };
-            const enteringViewItem = this.context.findViewItemByRouteInfo(propsToUse, this.id, false);
+            const swipeBackRouteInfo = this.getSwipeBackRouteInfo();
+            // First try to find the view in the current outlet, then search all outlets
+            let enteringViewItem = this.context.findViewItemByRouteInfo(swipeBackRouteInfo, this.id, false);
+            if (!enteringViewItem) {
+                enteringViewItem = this.context.findViewItemByRouteInfo(swipeBackRouteInfo, undefined, false);
+            }
             const leavingViewItem = this.context.findViewItemByRouteInfo(routeInfo, this.id, false);
-            /**
-             * When the gesture starts, kick off
-             * a transition that is controlled
-             * via a swipe gesture.
-             */
+            // Ensure the entering view is mounted so React keeps rendering it during the gesture.
+            // This is important when the view was previously marked for unmount but its
+            // ionPageElement is still in the DOM.
+            if (enteringViewItem && !enteringViewItem.mount) {
+                enteringViewItem.mount = true;
+            }
+            // When the gesture starts, kick off a transition controlled via swipe gesture
             if (enteringViewItem && leavingViewItem) {
                 await this.transitionPage(routeInfo, enteringViewItem, leavingViewItem, 'back', true);
             }
@@ -428,34 +1972,23 @@ class StackManager extends React.PureComponent {
         };
         const onEnd = (shouldContinue) => {
             if (shouldContinue) {
+                // User finished the swipe gesture, so complete the back navigation
                 this.skipTransition = true;
                 this.context.goBack();
             }
             else {
-                /**
-                 * In the event that the swipe
-                 * gesture was aborted, we should
-                 * re-hide the page that was going to enter.
-                 */
+                // Swipe gesture was aborted - re-hide the page that was going to enter
                 const { routeInfo } = this.props;
-                const propsToUse = this.prevProps && this.prevProps.routeInfo.pathname === routeInfo.pushedByRoute
-                    ? this.prevProps.routeInfo
-                    : { pathname: routeInfo.pushedByRoute || '' };
-                const enteringViewItem = this.context.findViewItemByRouteInfo(propsToUse, this.id, false);
+                const swipeBackRouteInfo = this.getSwipeBackRouteInfo();
+                // First try to find the view in the current outlet, then search all outlets
+                let enteringViewItem = this.context.findViewItemByRouteInfo(swipeBackRouteInfo, this.id, false);
+                if (!enteringViewItem) {
+                    enteringViewItem = this.context.findViewItemByRouteInfo(swipeBackRouteInfo, undefined, false);
+                }
                 const leavingViewItem = this.context.findViewItemByRouteInfo(routeInfo, this.id, false);
-                /**
-                 * Ionic React has a design defect where it
-                 * a) Unmounts the leaving view item when using parameterized routes
-                 * b) Considers the current view to be the entering view when using
-                 * parameterized routes
-                 *
-                 * As a result, we should not hide the view item here
-                 * as it will cause the current view to be hidden.
-                 */
+                // Don't hide if entering and leaving are the same (parameterized route edge case)
                 if (enteringViewItem !== leavingViewItem && (enteringViewItem === null || enteringViewItem === void 0 ? void 0 : enteringViewItem.ionPageElement) !== undefined) {
-                    const { ionPageElement } = enteringViewItem;
-                    ionPageElement.setAttribute('aria-hidden', 'true');
-                    ionPageElement.classList.add('ion-page-hidden');
+                    hideIonPageElement(enteringViewItem.ionPageElement);
                 }
             }
         };
@@ -465,7 +1998,23 @@ class StackManager extends React.PureComponent {
             onEnd,
         };
     }
-    async transitionPage(routeInfo, enteringViewItem, leavingViewItem, direction, progressAnimation = false) {
+    /**
+     * Animates the transition between the entering and leaving pages within the
+     * router outlet.
+     *
+     * @param routeInfo Info about the current route.
+     * @param enteringViewItem The view item that is entering.
+     * @param leavingViewItem The view item that is leaving.
+     * @param direction The direction of the transition.
+     * @param progressAnimation Indicates if the transition is part of a
+     * gesture controlled animation (e.g., swipe to go back).
+     * Defaults to `false`.
+     * @param skipAnimation When true, forces `duration: 0` so the page
+     * swap is instant (no visible animation). Used for ionPage outlets
+     * and back navigations that unmount the leaving view to prevent
+     * overlapping content during the transition. Defaults to `false`.
+     */
+    async transitionPage(routeInfo, enteringViewItem, leavingViewItem, direction, progressAnimation = false, skipAnimation = false) {
         const runCommit = async (enteringEl, leavingEl) => {
             const skipTransition = this.skipTransition;
             /**
@@ -493,10 +2042,18 @@ class StackManager extends React.PureComponent {
             }
             else {
                 enteringEl.classList.add('ion-page');
-                enteringEl.classList.add('ion-page-invisible');
+                /**
+                 * Only add ion-page-invisible if the element is not already visible.
+                 * During tab switches, the container page (e.g., TabContext wrapper) is
+                 * already visible and should remain so. Adding ion-page-invisible would
+                 * cause a flash where the visible page briefly becomes invisible.
+                 */
+                if (!isViewVisible(enteringEl)) {
+                    enteringEl.classList.add('ion-page-invisible');
+                }
             }
             await routerOutlet.commit(enteringEl, leavingEl, {
-                duration: skipTransition || directionToUse === undefined ? 0 : undefined,
+                duration: skipTransition || skipAnimation || directionToUse === undefined ? 0 : undefined,
                 direction: directionToUse,
                 showGoBack: !!routeInfo.pushedByRoute,
                 progressAnimation,
@@ -508,9 +2065,8 @@ class StackManager extends React.PureComponent {
         const directionToUse = direction !== null && direction !== void 0 ? direction : routeInfoFallbackDirection;
         if (enteringViewItem && enteringViewItem.ionPageElement && this.routerOutletElement) {
             if (leavingViewItem && leavingViewItem.ionPageElement && enteringViewItem === leavingViewItem) {
-                // If a page is transitioning to another version of itself
-                // we clone it so we can have an animation to show
-                const match = matchComponent(leavingViewItem.reactElement, routeInfo.pathname, true);
+                // Clone page for same-view transitions (e.g., /user/1 → /user/2)
+                const match = matchComponent(leavingViewItem.reactElement, routeInfo.pathname);
                 if (match) {
                     const newLeavingElement = clonePageElement(leavingViewItem.ionPageElement.outerHTML);
                     if (newLeavingElement) {
@@ -520,14 +2076,99 @@ class StackManager extends React.PureComponent {
                     }
                 }
                 else {
+                    // Route no longer matches (e.g., /user/1 → /settings)
                     await runCommit(enteringViewItem.ionPageElement, undefined);
                 }
             }
             else {
-                await runCommit(enteringViewItem.ionPageElement, leavingViewItem === null || leavingViewItem === void 0 ? void 0 : leavingViewItem.ionPageElement);
-                if (leavingViewItem && leavingViewItem.ionPageElement && !progressAnimation) {
-                    leavingViewItem.ionPageElement.classList.add('ion-page-hidden');
-                    leavingViewItem.ionPageElement.setAttribute('aria-hidden', 'true');
+                const leavingEl = leavingViewItem === null || leavingViewItem === void 0 ? void 0 : leavingViewItem.ionPageElement;
+                // For non-animated transitions, don't pass leaving element to commit() to avoid
+                // flicker caused by commit() briefly unhiding the leaving page
+                const isNonAnimatedTransition = directionToUse === undefined && !progressAnimation;
+                if (isNonAnimatedTransition && leavingEl) {
+                    /**
+                     * Flicker prevention for non-animated transitions:
+                     * Skip commit() entirely for simple visibility swaps (like tab switches).
+                     * commit() runs animation logic that can cause intermediate paints even with
+                     * duration: 0. Instead, we directly swap visibility classes and wait for
+                     * components to be ready before showing the entering element.
+                     */
+                    const enteringEl = enteringViewItem.ionPageElement;
+                    // Ensure entering element has proper base classes
+                    enteringEl.classList.add('ion-page');
+                    // Only add ion-page-invisible if not already visible (e.g., tab switches)
+                    if (!isViewVisible(enteringEl)) {
+                        enteringEl.classList.add('ion-page-invisible');
+                    }
+                    enteringEl.classList.remove('ion-page-hidden');
+                    enteringEl.removeAttribute('aria-hidden');
+                    // Handle can-go-back class since we're skipping commit() which normally sets this
+                    if (routeInfo.pushedByRoute) {
+                        enteringEl.classList.add('can-go-back');
+                    }
+                    else {
+                        enteringEl.classList.remove('can-go-back');
+                    }
+                    /**
+                     * Wait for components to be ready. Menu buttons start hidden (menu-button-hidden)
+                     * and become visible after componentDidLoad. Wait for hydration and visibility.
+                     */
+                    const waitForComponentsReady = () => {
+                        return new Promise((resolve) => {
+                            const checkReady = () => {
+                                const ionicComponents = enteringEl.querySelectorAll('ion-header, ion-toolbar, ion-buttons, ion-menu-button, ion-title, ion-content');
+                                const allHydrated = Array.from(ionicComponents).every((el) => el.classList.contains('hydrated'));
+                                const menuButtons = enteringEl.querySelectorAll('ion-menu-button');
+                                const menuButtonsReady = Array.from(menuButtons).every((el) => !el.classList.contains('menu-button-hidden'));
+                                return allHydrated && menuButtonsReady;
+                            };
+                            if (checkReady()) {
+                                resolve();
+                                return;
+                            }
+                            let resolved = false;
+                            const observer = new MutationObserver(() => {
+                                if (!resolved && checkReady()) {
+                                    resolved = true;
+                                    observer.disconnect();
+                                    resolve();
+                                }
+                            });
+                            observer.observe(enteringEl, {
+                                subtree: true,
+                                attributes: true,
+                                attributeFilter: ['class'],
+                            });
+                            setTimeout(() => {
+                                if (!resolved) {
+                                    resolved = true;
+                                    observer.disconnect();
+                                    resolve();
+                                }
+                            }, 100);
+                        });
+                    };
+                    await waitForComponentsReady();
+                    // Swap visibility in sync with browser's render cycle
+                    await new Promise((resolve) => {
+                        requestAnimationFrame(() => {
+                            enteringEl.classList.remove('ion-page-invisible');
+                            // Second rAF ensures entering is painted before hiding leaving
+                            requestAnimationFrame(() => {
+                                leavingEl.classList.add('ion-page-hidden');
+                                leavingEl.setAttribute('aria-hidden', 'true');
+                                resolve();
+                            });
+                        });
+                    });
+                }
+                else {
+                    await runCommit(enteringViewItem.ionPageElement, leavingEl);
+                    // For animated transitions, hide leaving element after commit completes
+                    if (leavingEl && !progressAnimation) {
+                        leavingEl.classList.add('ion-page-hidden');
+                        leavingEl.setAttribute('aria-hidden', 'true');
+                    }
                 }
             }
         }
@@ -535,20 +2176,25 @@ class StackManager extends React.PureComponent {
     render() {
         const { children } = this.props;
         const ionRouterOutlet = React.Children.only(children);
+        // Store reference for use in getParentPath() and handlePageTransition()
         this.ionRouterOutlet = ionRouterOutlet;
         const components = this.context.getChildrenToRender(this.id, this.ionRouterOutlet, this.props.routeInfo, () => {
+            // Callback triggers re-render when view items are modified during getChildrenToRender
             this.forceUpdate();
         });
         return (React.createElement(StackContext.Provider, { value: this.stackContextValue }, React.cloneElement(ionRouterOutlet, {
             ref: (node) => {
                 if (ionRouterOutlet.props.setRef) {
+                    // Needed to handle external refs from devs.
                     ionRouterOutlet.props.setRef(node);
                 }
                 if (ionRouterOutlet.props.forwardedRef) {
+                    // Needed to handle external refs from devs.
                     ionRouterOutlet.props.forwardedRef.current = node;
                 }
                 this.routerOutletElement = node;
                 const { ref } = ionRouterOutlet;
+                // Check for legacy refs.
                 if (typeof ref === 'function') {
                     ref(node);
                 }
@@ -559,169 +2205,422 @@ class StackManager extends React.PureComponent {
         return RouteManagerContext;
     }
 }
-function matchRoute(node, routeInfo) {
+/**
+ * Finds the `<Route />` node matching the current route info.
+ * If no `<Route />` can be matched, a fallback node is returned.
+ * Routes are prioritized by specificity (most specific first).
+ *
+ * @param node The root node to search for `<Route />` nodes.
+ * @param routeInfo The route information to match against.
+ * @param parentPath The parent path that was matched by the parent outlet (for nested routing)
+ */
+function findRouteByRouteInfo(node, routeInfo, parentPath) {
+    var _a;
     let matchedNode;
-    React.Children.forEach(node, (child) => {
+    let fallbackNode;
+    // `<Route />` nodes are rendered inside of a <Routes /> node
+    const routesChildren = (_a = getRoutesChildren(node)) !== null && _a !== void 0 ? _a : node;
+    // Collect all route children
+    const routeChildren = React.Children.toArray(routesChildren).filter((child) => React.isValidElement(child) && child.type === Route);
+    // Sort routes by specificity (most specific first)
+    const sortedRoutes = routeChildren.sort((a, b) => {
+        const pathA = a.props.path || '';
+        const pathB = b.props.path || '';
+        // Index routes come first
+        if (a.props.index && !b.props.index)
+            return -1;
+        if (!a.props.index && b.props.index)
+            return 1;
+        // Wildcard-only routes (*) should come LAST
+        const aIsWildcardOnly = pathA === '*';
+        const bIsWildcardOnly = pathB === '*';
+        if (!aIsWildcardOnly && bIsWildcardOnly)
+            return -1;
+        if (aIsWildcardOnly && !bIsWildcardOnly)
+            return 1;
+        // Exact matches (no wildcards/params) come before wildcard/param routes
+        const aHasWildcard = pathA.includes('*') || pathA.includes(':');
+        const bHasWildcard = pathB.includes('*') || pathB.includes(':');
+        if (!aHasWildcard && bHasWildcard)
+            return -1;
+        if (aHasWildcard && !bHasWildcard)
+            return 1;
+        // Among routes with same wildcard status, longer paths are more specific
+        if (pathA.length !== pathB.length) {
+            return pathB.length - pathA.length;
+        }
+        return 0;
+    });
+    // For nested routes in React Router 6, we need to extract the relative path
+    // that this outlet should be responsible for matching
+    const originalPathname = routeInfo.pathname;
+    let relativePathnameToMatch = routeInfo.pathname;
+    // Check if we have relative routes (routes that don't start with '/')
+    const hasRelativeRoutes = sortedRoutes.some((r) => r.props.path && !r.props.path.startsWith('/'));
+    const hasIndexRoute = sortedRoutes.some((r) => r.props.index);
+    // SIMPLIFIED: Trust React Router 6's matching more, compute relative path when parent is known
+    if ((hasRelativeRoutes || hasIndexRoute) && parentPath) {
+        const parentPrefix = parentPath.replace('/*', '');
+        // Normalize both paths to start with '/' for consistent comparison
+        const normalizedParent = stripTrailingSlash(parentPrefix.startsWith('/') ? parentPrefix : `/${parentPrefix}`);
+        const normalizedPathname = stripTrailingSlash(routeInfo.pathname);
+        // Only compute relative path if pathname is within parent scope
+        if (normalizedPathname.startsWith(normalizedParent + '/') || normalizedPathname === normalizedParent) {
+            const pathSegments = routeInfo.pathname.split('/').filter(Boolean);
+            const parentSegments = normalizedParent.split('/').filter(Boolean);
+            const relativeSegments = pathSegments.slice(parentSegments.length);
+            relativePathnameToMatch = relativeSegments.join('/'); // Empty string is valid for index routes
+        }
+    }
+    // Find the first matching route
+    for (const child of sortedRoutes) {
+        const childPath = child.props.path;
+        const isAbsoluteRoute = childPath && childPath.startsWith('/');
+        // Determine which pathname to match against:
+        // - For absolute routes: use the original full pathname
+        // - For relative routes with a parent: use the computed relative pathname
+        // - For relative routes at root level (no parent): use the original pathname
+        //   (matchPath will handle the relative-to-absolute normalization)
+        const pathnameToMatch = isAbsoluteRoute ? originalPathname : relativePathnameToMatch;
+        // Determine the path portion to match:
+        // - For absolute routes: use derivePathnameToMatch
+        // - For relative routes at root level (no parent): use original pathname
+        //   directly since matchPath normalizes both path and pathname
+        // - For relative routes with parent: use derivePathnameToMatch for wildcards,
+        //   or the computed relative pathname for non-wildcards
+        let pathForMatch;
+        if (isAbsoluteRoute) {
+            pathForMatch = derivePathnameToMatch(pathnameToMatch, childPath);
+        }
+        else if (!parentPath && childPath) {
+            // Root-level relative route: use the full pathname and let matchPath
+            // handle the normalization (it adds '/' to both path and pathname)
+            pathForMatch = originalPathname;
+        }
+        else if (childPath && childPath.includes('*')) {
+            // Relative wildcard route with parent path: use derivePathnameToMatch
+            pathForMatch = derivePathnameToMatch(pathnameToMatch, childPath);
+        }
+        else {
+            pathForMatch = pathnameToMatch;
+        }
         const match = matchPath({
-            pathname: routeInfo.pathname,
+            pathname: pathForMatch,
             componentProps: child.props,
         });
         if (match) {
             matchedNode = child;
+            break;
         }
-    });
+    }
     if (matchedNode) {
         return matchedNode;
     }
-    // If we haven't found a node
-    // try to find one that doesn't have a path or from prop, that will be our not found route
-    React.Children.forEach(node, (child) => {
-        if (!(child.props.path || child.props.from)) {
-            matchedNode = child;
+    // If we haven't found a node, try to find one that doesn't have a path prop (fallback route)
+    // BUT only return the fallback if the current pathname is within the outlet's scope.
+    // For outlets with absolute paths, compute the common prefix to determine scope.
+    const absolutePathRoutes = routeChildren.filter((r) => r.props.path && r.props.path.startsWith('/'));
+    // Determine if pathname is within scope before returning fallback
+    let isPathnameInScope = true;
+    if (absolutePathRoutes.length > 0) {
+        // Find common prefix of all absolute paths to determine outlet scope
+        const absolutePaths = absolutePathRoutes.map((r) => r.props.path);
+        const commonPrefix = computeCommonPrefix(absolutePaths);
+        // If we have a common prefix, check if the current pathname is within that scope
+        if (commonPrefix && commonPrefix !== '/') {
+            isPathnameInScope = routeInfo.pathname.startsWith(commonPrefix);
         }
-    });
-    return matchedNode;
+    }
+    // Only look for fallback route if pathname is within scope
+    if (isPathnameInScope) {
+        for (const child of routeChildren) {
+            if (!child.props.path) {
+                fallbackNode = child;
+                break;
+            }
+        }
+    }
+    return matchedNode !== null && matchedNode !== void 0 ? matchedNode : fallbackNode;
 }
 function matchComponent(node, pathname, forceExact) {
+    var _a;
+    const routePath = (_a = node === null || node === void 0 ? void 0 : node.props) === null || _a === void 0 ? void 0 : _a.path;
+    const pathnameToMatch = derivePathnameToMatch(pathname, routePath);
     return matchPath({
-        pathname,
-        componentProps: Object.assign(Object.assign({}, node.props), { exact: forceExact }),
+        pathname: pathnameToMatch,
+        componentProps: Object.assign(Object.assign({}, node.props), { end: forceExact }),
     });
 }
 
-class IonRouterInner extends React.PureComponent {
-    constructor(props) {
-        super(props);
-        this.exitViewFromOtherOutletHandlers = [];
-        this.locationHistory = new LocationHistory();
-        this.viewStack = new ReactRouterViewStack();
-        this.routeMangerContextState = {
-            canGoBack: () => this.locationHistory.canGoBack(),
-            clearOutlet: this.viewStack.clear,
-            findViewItemByPathname: this.viewStack.findViewItemByPathname,
-            getChildrenToRender: this.viewStack.getChildrenToRender,
-            goBack: () => this.handleNavigateBack(),
-            createViewItem: this.viewStack.createViewItem,
-            findViewItemByRouteInfo: this.viewStack.findViewItemByRouteInfo,
-            findLeavingViewItemByRouteInfo: this.viewStack.findLeavingViewItemByRouteInfo,
-            addViewItem: this.viewStack.add,
-            unMountViewItem: this.viewStack.remove,
-        };
-        const routeInfo = {
-            id: generateId('routeInfo'),
-            pathname: this.props.location.pathname,
-            search: this.props.location.search,
-        };
-        this.locationHistory.add(routeInfo);
-        this.handleChangeTab = this.handleChangeTab.bind(this);
-        this.handleResetTab = this.handleResetTab.bind(this);
-        this.handleNativeBack = this.handleNativeBack.bind(this);
-        this.handleNavigate = this.handleNavigate.bind(this);
-        this.handleNavigateBack = this.handleNavigateBack.bind(this);
-        this.props.registerHistoryListener(this.handleHistoryChange.bind(this));
-        this.handleSetCurrentTab = this.handleSetCurrentTab.bind(this);
-        this.state = {
-            routeInfo,
-        };
+/**
+ * `IonRouter` is responsible for managing the application's navigation
+ * state, tracking the history of visited routes, and coordinating
+ * transitions between different views. It intercepts route changes from
+ * React Router and translates them into actions that Ionic can understand
+ * and animate.
+ */
+const filterUndefinedParams = (params) => {
+    const result = {};
+    for (const key of Object.keys(params)) {
+        const value = params[key];
+        if (value !== undefined) {
+            result[key] = value;
+        }
     }
-    handleChangeTab(tab, path, routeOptions) {
-        if (!path) {
+    return result;
+};
+const areParamsEqual = (a, b) => {
+    const paramsA = a || {};
+    const paramsB = b || {};
+    const keysA = Object.keys(paramsA);
+    const keysB = Object.keys(paramsB);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    return keysA.every((key) => {
+        const valueA = paramsA[key];
+        const valueB = paramsB[key];
+        if (Array.isArray(valueA) && Array.isArray(valueB)) {
+            if (valueA.length !== valueB.length) {
+                return false;
+            }
+            return valueA.every((entry, idx) => entry === valueB[idx]);
+        }
+        return valueA === valueB;
+    });
+};
+const IonRouter = ({ children, registerHistoryListener }) => {
+    const location = useLocation();
+    const navigate = useNavigate();
+    const didMountRef = useRef(false);
+    const locationHistory = useRef(new LocationHistory());
+    const currentTab = useRef(undefined);
+    const viewStack = useRef(new ReactRouterViewStack());
+    const incomingRouteParams = useRef(null);
+    /**
+     * Tracks location keys that the user navigated away from via browser back.
+     * When a POP event's destination key matches the top of this stack, it's a
+     * browser forward navigation. Uses React Router's unique location.key
+     * instead of URLs to correctly handle duplicate URLs in history (e.g.,
+     * navigating to /details, then /settings, then /details via routerLink,
+     * then pressing back).
+     * Cleared on PUSH (new navigation invalidates forward history).
+     */
+    const forwardStack = useRef([]);
+    /**
+     * Tracks the current location key so we can push it onto the forward stack
+     * when navigating back. Updated after each history change.
+     */
+    const currentLocationKeyRef = useRef(location.key);
+    const [routeInfo, setRouteInfo] = useState({
+        id: generateId('routeInfo'),
+        pathname: location.pathname,
+        search: location.search,
+        params: {},
+    });
+    useEffect(() => {
+        if (didMountRef.current) {
             return;
         }
-        const routeInfo = this.locationHistory.getCurrentRouteInfoForTab(tab);
-        const [pathname, search] = path.split('?');
-        if (routeInfo) {
-            this.incomingRouteParams = Object.assign(Object.assign({}, routeInfo), { routeAction: 'push', routeDirection: 'none' });
-            if (routeInfo.pathname === pathname) {
-                this.incomingRouteParams.routeOptions = routeOptions;
-                this.props.history.push(routeInfo.pathname + (routeInfo.search || ''));
-            }
-            else {
-                this.incomingRouteParams.pathname = pathname;
-                this.incomingRouteParams.search = search ? '?' + search : undefined;
-                this.incomingRouteParams.routeOptions = routeOptions;
-                this.props.history.push(pathname + (search ? '?' + search : ''));
+        // Seed the history stack with the initial location and begin listening
+        // for future navigations once React has committed the mount. This avoids
+        // duplicate entries when React StrictMode runs an extra render pre-commit.
+        locationHistory.current.add(routeInfo);
+        registerHistoryListener(handleHistoryChange);
+        didMountRef.current = true;
+    }, []);
+    // Sync route params extracted by React Router's path matching back into routeInfo.
+    // The view stack's match may contain params (e.g., :id) not present in the initial routeInfo.
+    useEffect(() => {
+        var _a;
+        const activeView = viewStack.current.findViewItemByRouteInfo(routeInfo, undefined, true);
+        const matchedParams = (_a = activeView === null || activeView === void 0 ? void 0 : activeView.routeData.match) === null || _a === void 0 ? void 0 : _a.params;
+        if (matchedParams) {
+            const paramsCopy = filterUndefinedParams(Object.assign({}, matchedParams));
+            if (areParamsEqual(routeInfo.params, paramsCopy)) {
+                return;
             }
+            const updatedRouteInfo = Object.assign(Object.assign({}, routeInfo), { params: paramsCopy });
+            locationHistory.current.update(updatedRouteInfo);
+            setRouteInfo(updatedRouteInfo);
         }
-        else {
-            this.handleNavigate(pathname, 'push', 'none', undefined, routeOptions, tab);
-        }
-    }
-    handleHistoryChange(location, action) {
-        var _a, _b, _c;
+    }, [routeInfo]);
+    /**
+     * Triggered whenever the history changes, either through user navigation
+     * or programmatic changes. It transforms the raw browser history changes
+     * into `RouteInfo` objects, which are needed Ionic's animations and
+     * navigation patterns.
+     *
+     * @param location The current location object from the history.
+     * @param action The action that triggered the history change.
+     */
+    const handleHistoryChange = (location, action) => {
+        var _a, _b, _c, _d, _e;
         let leavingLocationInfo;
-        if (this.incomingRouteParams) {
-            if (this.incomingRouteParams.routeAction === 'replace') {
-                leavingLocationInfo = this.locationHistory.previous();
+        /**
+         * A programmatic navigation was triggered.
+         * e.g., `<Navigate />`, `navigate()`, or `handleNavigate()`
+         */
+        if (incomingRouteParams.current) {
+            /**
+             * The current history entry is overwritten, so the previous entry
+             * is the one we are leaving.
+             */
+            if (((_a = incomingRouteParams.current) === null || _a === void 0 ? void 0 : _a.routeAction) === 'replace') {
+                leavingLocationInfo = locationHistory.current.previous();
             }
             else {
-                leavingLocationInfo = this.locationHistory.current();
+                // If the action is 'push' or 'pop', we want to use the current route.
+                leavingLocationInfo = locationHistory.current.current();
             }
         }
         else {
-            leavingLocationInfo = this.locationHistory.current();
+            /**
+             * An external navigation was triggered
+             * e.g., browser back/forward button or direct link
+             *
+             * The leaving location is the current route.
+             */
+            leavingLocationInfo = locationHistory.current.current();
         }
         const leavingUrl = leavingLocationInfo.pathname + leavingLocationInfo.search;
         if (leavingUrl !== location.pathname) {
-            if (!this.incomingRouteParams) {
+            if (!incomingRouteParams.current) {
+                // Determine if the destination is a tab route by checking if it matches
+                // the pattern of tab routes (containing /tabs/ in the path)
+                const isTabRoute = /\/tabs(\/|$)/.test(location.pathname);
+                const tabToUse = isTabRoute ? currentTab.current : undefined;
+                // If we're leaving tabs entirely, clear the current tab
+                if (!isTabRoute && currentTab.current) {
+                    currentTab.current = undefined;
+                }
+                /**
+                 * A `REPLACE` action can be triggered by React Router's
+                 * `<Navigate />` component.
+                 */
                 if (action === 'REPLACE') {
-                    this.incomingRouteParams = {
+                    incomingRouteParams.current = {
                         routeAction: 'replace',
                         routeDirection: 'none',
-                        tab: this.currentTab,
+                        tab: tabToUse,
                     };
                 }
+                /**
+                 * A `POP` action can be triggered by the browser's back/forward
+                 * button. Both fire as POP events, so we use a forward stack to
+                 * distinguish them: when going back, we push the leaving pathname
+                 * onto the stack. When the next POP's destination matches the top
+                 * of the stack, it's a forward navigation.
+                 */
                 if (action === 'POP') {
-                    const currentRoute = this.locationHistory.current();
-                    if (currentRoute && currentRoute.pushedByRoute) {
-                        const prevInfo = this.locationHistory.findLastLocation(currentRoute);
-                        this.incomingRouteParams = Object.assign(Object.assign({}, prevInfo), { routeAction: 'pop', routeDirection: 'back' });
+                    const currentRoute = locationHistory.current.current();
+                    const isForwardNavigation = forwardStack.current.length > 0 &&
+                        forwardStack.current[forwardStack.current.length - 1] === location.key;
+                    if (isForwardNavigation) {
+                        forwardStack.current.pop();
+                        incomingRouteParams.current = {
+                            routeAction: 'push',
+                            routeDirection: 'forward',
+                            tab: tabToUse,
+                        };
+                    }
+                    else if (currentRoute && currentRoute.pushedByRoute) {
+                        // Back navigation. Record current location key for potential forward
+                        forwardStack.current.push(currentLocationKeyRef.current);
+                        const prevInfo = locationHistory.current.findLastLocation(currentRoute);
+                        incomingRouteParams.current = Object.assign(Object.assign({}, prevInfo), { routeAction: 'pop', routeDirection: 'back' });
                     }
                     else {
-                        this.incomingRouteParams = {
+                        // It's a non-linear history path like a direct link.
+                        incomingRouteParams.current = {
                             routeAction: 'pop',
                             routeDirection: 'none',
-                            tab: this.currentTab,
+                            tab: tabToUse,
                         };
                     }
                 }
-                if (!this.incomingRouteParams) {
-                    this.incomingRouteParams = {
+                if (!incomingRouteParams.current) {
+                    const state = location.state;
+                    incomingRouteParams.current = {
                         routeAction: 'push',
-                        routeDirection: ((_a = location.state) === null || _a === void 0 ? void 0 : _a.direction) || 'forward',
-                        routeOptions: (_b = location.state) === null || _b === void 0 ? void 0 : _b.routerOptions,
-                        tab: this.currentTab,
+                        routeDirection: (state === null || state === void 0 ? void 0 : state.direction) || 'forward',
+                        routeOptions: state === null || state === void 0 ? void 0 : state.routerOptions,
+                        tab: tabToUse,
                     };
                 }
             }
+            // New navigation (PUSH) invalidates browser forward history,
+            // so clear our forward stack to stay in sync.
+            if (action === 'PUSH') {
+                forwardStack.current = [];
+            }
             let routeInfo;
-            if ((_c = this.incomingRouteParams) === null || _c === void 0 ? void 0 : _c.id) {
-                routeInfo = Object.assign(Object.assign({}, this.incomingRouteParams), { lastPathname: leavingLocationInfo.pathname });
-                this.locationHistory.add(routeInfo);
+            // If we're navigating away from tabs to a non-tab route, clear the current tab
+            if (!/\/tabs(\/|$)/.test(location.pathname) && currentTab.current) {
+                currentTab.current = undefined;
+            }
+            /**
+             * An existing id indicates that it's re-activating an existing route.
+             * e.g., tab switching or navigating back to a previous route
+             */
+            if ((_b = incomingRouteParams.current) === null || _b === void 0 ? void 0 : _b.id) {
+                routeInfo = Object.assign(Object.assign({}, incomingRouteParams.current), { lastPathname: leavingLocationInfo.pathname });
+                locationHistory.current.add(routeInfo);
+                /**
+                 * A new route is being created since it's not re-activating
+                 * an existing route.
+                 */
             }
             else {
-                const isPushed = this.incomingRouteParams.routeAction === 'push' && this.incomingRouteParams.routeDirection === 'forward';
-                routeInfo = Object.assign(Object.assign({ id: generateId('routeInfo') }, this.incomingRouteParams), { lastPathname: leavingLocationInfo.pathname, pathname: location.pathname, search: location.search, params: this.props.match.params, prevRouteLastPathname: leavingLocationInfo.lastPathname });
+                const isPushed = ((_c = incomingRouteParams.current) === null || _c === void 0 ? void 0 : _c.routeAction) === 'push' &&
+                    incomingRouteParams.current.routeDirection === 'forward';
+                routeInfo = Object.assign(Object.assign({ id: generateId('routeInfo') }, incomingRouteParams.current), { lastPathname: leavingLocationInfo.pathname, pathname: location.pathname, search: location.search, params: ((_d = incomingRouteParams.current) === null || _d === void 0 ? void 0 : _d.params)
+                        ? filterUndefinedParams(incomingRouteParams.current.params)
+                        : {}, prevRouteLastPathname: leavingLocationInfo.lastPathname });
                 if (isPushed) {
-                    routeInfo.tab = leavingLocationInfo.tab;
+                    // Only inherit tab from leaving route if we don't already have one.
+                    // This preserves tab context for same-tab navigation while allowing cross-tab navigation.
+                    routeInfo.tab = routeInfo.tab || leavingLocationInfo.tab;
                     routeInfo.pushedByRoute = leavingLocationInfo.pathname;
+                    // Triggered by a browser back button or handleNavigateBack.
                 }
                 else if (routeInfo.routeAction === 'pop') {
-                    const r = this.locationHistory.findLastLocation(routeInfo);
+                    // Find the route that pushed this one.
+                    const r = locationHistory.current.findLastLocation(routeInfo);
                     routeInfo.pushedByRoute = r === null || r === void 0 ? void 0 : r.pushedByRoute;
+                    // Navigating to a new tab.
                 }
                 else if (routeInfo.routeAction === 'push' && routeInfo.tab !== leavingLocationInfo.tab) {
-                    // If we are switching tabs grab the last route info for the tab and use its pushedByRoute
-                    const lastRoute = this.locationHistory.getCurrentRouteInfoForTab(routeInfo.tab);
-                    routeInfo.pushedByRoute = lastRoute === null || lastRoute === void 0 ? void 0 : lastRoute.pushedByRoute;
+                    /**
+                     * If we are switching tabs grab the last route info for the
+                     * tab and use its `pushedByRoute`.
+                     */
+                    const lastRoute = locationHistory.current.getCurrentRouteInfoForTab(routeInfo.tab);
+                    /**
+                     * Tab bar switches (direction 'none') should not create cross-tab back
+                     * navigation. Only inherit pushedByRoute from the tab's own history.
+                     */
+                    if (routeInfo.routeDirection === 'none') {
+                        routeInfo.pushedByRoute = lastRoute === null || lastRoute === void 0 ? void 0 : lastRoute.pushedByRoute;
+                    }
+                    else {
+                        routeInfo.pushedByRoute = (_e = lastRoute === null || lastRoute === void 0 ? void 0 : lastRoute.pushedByRoute) !== null && _e !== void 0 ? _e : leavingLocationInfo.pathname;
+                    }
+                    // Triggered by `navigate()` with replace or a `<Navigate />` component, etc.
                 }
                 else if (routeInfo.routeAction === 'replace') {
-                    // Make sure to set the lastPathname, etc.. to the current route so the page transitions out
-                    const currentRouteInfo = this.locationHistory.current();
                     /**
-                     * If going from /home to /child, then replacing from
-                     * /child to /home, we don't want the route info to
-                     * say that /home was pushed by /home which is not correct.
+                     * Make sure to set the `lastPathname`, etc.. to the current route
+                     * so the page transitions out.
+                     */
+                    const currentRouteInfo = locationHistory.current.current();
+                    /**
+                     * Special handling for `replace` to ensure correct `pushedByRoute`
+                     * and `lastPathname`.
+                     *
+                     * If going from `/home` to `/child`, then replacing from
+                     * `/child` to `/home`, we don't want the route info to
+                     * say that `/home` was pushed by `/home` which is not correct.
                      */
                     const currentPushedBy = currentRouteInfo === null || currentRouteInfo === void 0 ? void 0 : currentRouteInfo.pushedByRoute;
                     const pushedByRoute = currentPushedBy !== undefined && currentPushedBy !== routeInfo.pathname
@@ -739,46 +2638,110 @@ class IonRouterInner extends React.PureComponent {
                     routeInfo.routeDirection = routeInfo.routeDirection || (currentRouteInfo === null || currentRouteInfo === void 0 ? void 0 : currentRouteInfo.routeDirection);
                     routeInfo.routeAnimation = routeInfo.routeAnimation || (currentRouteInfo === null || currentRouteInfo === void 0 ? void 0 : currentRouteInfo.routeAnimation);
                 }
-                this.locationHistory.add(routeInfo);
+                locationHistory.current.add(routeInfo);
             }
-            this.setState({
-                routeInfo,
-            });
+            setRouteInfo(routeInfo);
         }
-        this.incomingRouteParams = undefined;
-    }
+        // Update the current location key after processing the history change.
+        // This ensures the forward stack records the correct key when navigating back.
+        currentLocationKeyRef.current = location.key;
+        incomingRouteParams.current = null;
+    };
     /**
-     * history@4.x uses goBack(), history@5.x uses back()
-     * TODO: If support for React Router <=5 is dropped
-     * this logic is no longer needed. We can just
-     * assume back() is available.
+     * Resets the specified tab to its initial, root route.
+     *
+     * @param tab The tab to reset.
+     * @param originalHref The original href for the tab.
+     * @param originalRouteOptions The original route options for the tab.
      */
-    handleNativeBack() {
-        const history = this.props.history;
-        const goBack = history.goBack || history.back;
-        goBack();
-    }
-    handleNavigate(path, routeAction, routeDirection, routeAnimation, routeOptions, tab) {
-        this.incomingRouteParams = Object.assign(this.incomingRouteParams || {}, {
-            routeAction,
-            routeDirection,
-            routeOptions,
-            routeAnimation,
-            tab,
-        });
-        if (routeAction === 'push') {
-            this.props.history.push(path);
+    const handleResetTab = (tab, originalHref, originalRouteOptions) => {
+        const routeInfo = locationHistory.current.getFirstRouteInfoForTab(tab);
+        if (routeInfo) {
+            const newRouteInfo = Object.assign({}, routeInfo);
+            newRouteInfo.pathname = originalHref;
+            newRouteInfo.routeOptions = originalRouteOptions;
+            incomingRouteParams.current = Object.assign(Object.assign({}, newRouteInfo), { routeAction: 'pop', routeDirection: 'back' });
+            navigate(newRouteInfo.pathname + (newRouteInfo.search || ''));
+        }
+    };
+    /**
+     * Handles tab changes.
+     *
+     * @param tab The tab to switch to.
+     * @param path The new path for the tab.
+     * @param routeOptions Additional route options.
+     */
+    const handleChangeTab = (tab, path, routeOptions) => {
+        if (!path) {
+            return;
+        }
+        const routeInfo = locationHistory.current.getCurrentRouteInfoForTab(tab);
+        const [pathname, search] = path.split('?');
+        // User has navigated to the current tab before.
+        if (routeInfo) {
+            const routeParams = Object.assign(Object.assign({}, routeInfo), { routeAction: 'push', routeDirection: 'none' });
+            /**
+             * User is navigating to the same tab.
+             * e.g., `/tabs/home` → `/tabs/home`
+             */
+            if (routeInfo.pathname === pathname) {
+                incomingRouteParams.current = Object.assign(Object.assign({}, routeParams), { routeOptions });
+                navigate(routeInfo.pathname + (routeInfo.search || ''));
+                /**
+                 * User is navigating to a different tab.
+                 * e.g., `/tabs/home` → `/tabs/settings`
+                 */
+            }
+            else {
+                incomingRouteParams.current = Object.assign(Object.assign({}, routeParams), { pathname, search: search ? '?' + search : undefined, routeOptions });
+                navigate(pathname + (search ? '?' + search : ''));
+            }
+            // User has not navigated to this tab before.
         }
         else {
-            this.props.history.replace(path);
+            handleNavigate(pathname, 'push', 'none', undefined, routeOptions, tab);
         }
-    }
-    handleNavigateBack(defaultHref = '/', routeAnimation) {
+    };
+    /**
+     * Set the current active tab in `locationHistory`.
+     * This is crucial for maintaining tab history since each tab has
+     * its own navigation stack.
+     *
+     * @param tab The tab to set as active.
+     */
+    const handleSetCurrentTab = (tab) => {
+        currentTab.current = tab;
+        const ri = Object.assign({}, locationHistory.current.current());
+        if (ri.tab !== tab) {
+            ri.tab = tab;
+            locationHistory.current.update(ri);
+        }
+    };
+    /**
+     * Handles the native back button press.
+     * It's usually called when a user presses the platform-native back action.
+     */
+    const handleNativeBack = () => {
+        navigate(-1);
+    };
+    /**
+     * Used to manage the back navigation within the Ionic React's routing
+     * system. It's deeply integrated with Ionic's view lifecycle, animations,
+     * and its custom history tracking (`locationHistory`) to provide a
+     * native-like transition and maintain correct application state.
+     *
+     * @param defaultHref The fallback URL to navigate to if there's no
+     * previous entry in the `locationHistory` stack.
+     * @param routeAnimation A custom animation builder to override the
+     * default "back" animation.
+     */
+    const handleNavigateBack = (defaultHref = '/', routeAnimation) => {
         const config = getConfig();
         defaultHref = defaultHref ? defaultHref : config && config.get('backButtonDefaultHref');
-        const routeInfo = this.locationHistory.current();
+        const routeInfo = locationHistory.current.current();
+        // It's a linear navigation.
         if (routeInfo && routeInfo.pushedByRoute) {
-            const prevInfo = this.locationHistory.findLastLocation(routeInfo);
+            const prevInfo = locationHistory.current.findLastLocation(routeInfo);
             if (prevInfo) {
                 /**
                  * This needs to be passed to handleNavigate
@@ -786,160 +2749,240 @@ class IonRouterInner extends React.PureComponent {
                  * will be overridden.
                  */
                 const incomingAnimation = routeAnimation || routeInfo.routeAnimation;
-                this.incomingRouteParams = Object.assign(Object.assign({}, prevInfo), { routeAction: 'pop', routeDirection: 'back', routeAnimation: incomingAnimation });
-                if (routeInfo.lastPathname === routeInfo.pushedByRoute ||
-                    /**
-                     * We need to exclude tab switches/tab
-                     * context changes here because tabbed
-                     * navigation is not linear, but router.back()
-                     * will go back in a linear fashion.
-                     */
-                    (prevInfo.pathname === routeInfo.pushedByRoute && routeInfo.tab === '' && prevInfo.tab === '')) {
-                    /**
-                     * history@4.x uses goBack(), history@5.x uses back()
-                     * TODO: If support for React Router <=5 is dropped
-                     * this logic is no longer needed. We can just
-                     * assume back() is available.
-                     */
-                    const history = this.props.history;
-                    const goBack = history.goBack || history.back;
-                    goBack();
+                incomingRouteParams.current = Object.assign(Object.assign({}, prevInfo), { routeAction: 'pop', routeDirection: 'back', routeAnimation: incomingAnimation });
+                /**
+                 * Check if it's a simple linear back navigation (not tabbed).
+                 * e.g., `/home` → `/settings` → back to `/home`
+                 */
+                const condition1 = routeInfo.lastPathname === routeInfo.pushedByRoute;
+                const condition2 = prevInfo.pathname === routeInfo.pushedByRoute && routeInfo.tab === '' && prevInfo.tab === '';
+                if (condition1 || condition2) {
+                    // Record the current location key so browser forward is detectable
+                    forwardStack.current.push(currentLocationKeyRef.current);
+                    navigate(-1);
                 }
                 else {
-                    this.handleNavigate(prevInfo.pathname + (prevInfo.search || ''), 'pop', 'back', incomingAnimation);
+                    /**
+                     * It's a non-linear back navigation.
+                     * e.g., direct link or tab switch or nested navigation with redirects
+                     * Clear forward stack since the REPLACE-based navigate resets history
+                     * position, making any prior forward entries unreachable.
+                     */
+                    forwardStack.current = [];
+                    handleNavigate(prevInfo.pathname + (prevInfo.search || ''), 'pop', 'back', incomingAnimation);
                 }
+                /**
+                 * `pushedByRoute` exists, but no corresponding previous entry in
+                 * the history stack.
+                 */
             }
             else {
-                this.handleNavigate(defaultHref, 'pop', 'back', routeAnimation);
+                handleNavigate(defaultHref, 'pop', 'back', routeAnimation);
             }
+            /**
+             * No `pushedByRoute` (e.g., initial page load or tab root).
+             * Tabs with no back history should not navigate.
+             */
         }
         else {
-            this.handleNavigate(defaultHref, 'pop', 'back', routeAnimation);
-        }
-    }
-    handleResetTab(tab, originalHref, originalRouteOptions) {
-        const routeInfo = this.locationHistory.getFirstRouteInfoForTab(tab);
-        if (routeInfo) {
-            const newRouteInfo = Object.assign({}, routeInfo);
-            newRouteInfo.pathname = originalHref;
-            newRouteInfo.routeOptions = originalRouteOptions;
-            this.incomingRouteParams = Object.assign(Object.assign({}, newRouteInfo), { routeAction: 'pop', routeDirection: 'back' });
-            this.props.history.push(newRouteInfo.pathname + (newRouteInfo.search || ''));
+            if (routeInfo && routeInfo.tab) {
+                return;
+            }
+            handleNavigate(defaultHref, 'pop', 'back', routeAnimation);
         }
-    }
-    handleSetCurrentTab(tab) {
-        this.currentTab = tab;
-        const ri = Object.assign({}, this.locationHistory.current());
-        if (ri.tab !== tab) {
-            ri.tab = tab;
-            this.locationHistory.update(ri);
+    };
+    /**
+     * Used to programmatically navigate through the app.
+     *
+     * @param path The path to navigate to.
+     * @param routeAction The action to take (push, replace, etc.).
+     * @param routeDirection The direction of the navigation (forward,
+     * back, etc.).
+     * @param routeAnimation The animation to use for the transition.
+     * @param routeOptions Additional options for the route.
+     * @param tab The tab to navigate to, if applicable.
+     */
+    const handleNavigate = (path, routeAction, routeDirection, routeAnimation, routeOptions, tab) => {
+        var _a;
+        const normalizedRouteDirection = routeAction === 'push' && routeDirection === undefined ? 'forward' : routeDirection;
+        // When navigating from tabs context, we need to determine if the destination
+        // is also within tabs. If not, we should clear the tab context.
+        let navigationTab = tab;
+        // If no explicit tab is provided and we're in a tab context,
+        // check if the destination path is outside of the current tab context
+        if (!tab && currentTab.current && path) {
+            // Get the current route info to understand where we are
+            const currentRoute = locationHistory.current.current();
+            // If we're navigating from a tab route to a completely different path structure,
+            // we should clear the tab context. This is a simplified check that assumes
+            // tab routes share a common parent path.
+            if (currentRoute && currentRoute.pathname) {
+                // Extract the base tab path (e.g., /routing/tabs from /routing/tabs/home)
+                const tabBaseMatch = currentRoute.pathname.match(/^(.*\/tabs)/);
+                if (tabBaseMatch) {
+                    const tabBasePath = tabBaseMatch[1];
+                    // If the new path doesn't start with the tab base path, we're leaving tabs
+                    if (!path.startsWith(tabBasePath)) {
+                        currentTab.current = undefined;
+                        navigationTab = undefined;
+                    }
+                    else {
+                        // Still within tabs, preserve the tab context
+                        navigationTab = currentTab.current;
+                    }
+                }
+            }
         }
-    }
-    render() {
-        return (React.createElement(RouteManagerContext.Provider, { value: this.routeMangerContextState },
-            React.createElement(NavManager, { ionRoute: IonRouteInner, ionRedirect: {}, stackManager: StackManager, routeInfo: this.state.routeInfo, onNativeBack: this.handleNativeBack, onNavigateBack: this.handleNavigateBack, onNavigate: this.handleNavigate, onSetCurrentTab: this.handleSetCurrentTab, onChangeTab: this.handleChangeTab, onResetTab: this.handleResetTab, locationHistory: this.locationHistory }, this.props.children)));
-    }
-}
-const IonRouter = withRouter(IonRouterInner);
+        const baseParams = (_a = incomingRouteParams.current) !== null && _a !== void 0 ? _a : {};
+        incomingRouteParams.current = Object.assign(Object.assign({}, baseParams), { routeAction, routeDirection: normalizedRouteDirection, routeOptions,
+            routeAnimation, tab: navigationTab });
+        navigate(path, { replace: routeAction !== 'push' });
+    };
+    const routeMangerContextValue = {
+        canGoBack: () => locationHistory.current.canGoBack(),
+        clearOutlet: viewStack.current.clear,
+        findViewItemByPathname: viewStack.current.findViewItemByPathname,
+        getChildrenToRender: viewStack.current.getChildrenToRender,
+        getViewItemsForOutlet: viewStack.current.getViewItemsForOutlet.bind(viewStack.current),
+        goBack: () => handleNavigateBack(),
+        createViewItem: viewStack.current.createViewItem,
+        findViewItemByRouteInfo: viewStack.current.findViewItemByRouteInfo,
+        findLeavingViewItemByRouteInfo: viewStack.current.findLeavingViewItemByRouteInfo,
+        addViewItem: viewStack.current.add,
+        unMountViewItem: viewStack.current.remove,
+    };
+    return (React.createElement(RouteManagerContext.Provider, { value: routeMangerContextValue },
+        React.createElement(NavManager, { ionRoute: IonRouteInner, stackManager: StackManager, routeInfo: routeInfo, onNativeBack: handleNativeBack, onNavigateBack: handleNavigateBack, onNavigate: handleNavigate, onSetCurrentTab: handleSetCurrentTab, onChangeTab: handleChangeTab, onResetTab: handleResetTab, locationHistory: locationHistory.current }, children)));
+};
 IonRouter.displayName = 'IonRouter';
 
-class IonReactRouter extends React.Component {
-    constructor(props) {
-        super(props);
-        const { history } = props, rest = __rest(props, ["history"]);
-        this.history = history || createBrowserHistory(rest);
-        this.history.listen(this.handleHistoryChange.bind(this));
-        this.registerHistoryListener = this.registerHistoryListener.bind(this);
-    }
+/**
+ * `IonReactRouter` facilitates the integration of Ionic's specific
+ * navigation and UI management with the standard React Router mechanisms,
+ * allowing an inner Ionic-specific router (`IonRouter`) to react to
+ * navigation events.
+ */
+/**
+ * This component acts as a bridge to ensure React Router hooks like
+ * `useLocation` and `useNavigationType` are called within the valid
+ * context of a `<BrowserRouter>`.
+ *
+ * It was split from `IonReactRouter` because these hooks must be
+ * descendants of a `<Router>` component, which `BrowserRouter` provides.
+ */
+const RouterContent$2 = ({ children }) => {
+    const location = useLocation();
+    const navigationType = useNavigationType();
+    const historyListenHandler = useRef();
+    const registerHistoryListener = useCallback((cb) => {
+        historyListenHandler.current = cb;
+    }, []);
     /**
-     * history@4.x passes separate location and action
-     * params. history@5.x passes location and action
-     * together as a single object.
-     * TODO: If support for React Router <=5 is dropped
-     * this logic is no longer needed. We can just assume
-     * a single object with both location and action.
+     * Processes navigation changes within the application.
+     *
+     * Its purpose is to relay the current `location` and the associated
+     * `action` ('PUSH', 'POP', or 'REPLACE') to any registered listeners,
+     * primarily for `IonRouter` to manage Ionic-specific UI updates and
+     * navigation stack behavior.
+     *
+     * @param loc The current browser history location object.
+     * @param act The type of navigation action ('PUSH', 'POP', or
+     * 'REPLACE').
      */
-    handleHistoryChange(location, action) {
-        const locationValue = location.location || location;
-        const actionValue = location.action || action;
-        if (this.historyListenHandler) {
-            this.historyListenHandler(locationValue, actionValue);
+    const handleHistoryChange = useCallback((loc, act) => {
+        if (historyListenHandler.current) {
+            historyListenHandler.current(loc, act);
         }
-    }
-    registerHistoryListener(cb) {
-        this.historyListenHandler = cb;
-    }
-    render() {
-        const _a = this.props, { children } = _a, props = __rest(_a, ["children"]);
-        return (React.createElement(Router, Object.assign({ history: this.history }, props),
-            React.createElement(IonRouter, { registerHistoryListener: this.registerHistoryListener }, children)));
-    }
-}
+    }, []);
+    useEffect(() => {
+        handleHistoryChange(location, navigationType);
+    }, [location, navigationType, handleHistoryChange]);
+    return React.createElement(IonRouter, { registerHistoryListener: registerHistoryListener }, children);
+};
+const IonReactRouter = (_a) => {
+    var { children } = _a, browserRouterProps = __rest(_a, ["children"]);
+    return (React.createElement(BrowserRouter, Object.assign({}, browserRouterProps),
+        React.createElement(RouterContent$2, null, children)));
+};
 
-class IonReactMemoryRouter extends React.Component {
-    constructor(props) {
-        super(props);
-        this.history = props.history;
-        this.history.listen(this.handleHistoryChange.bind(this));
-        this.registerHistoryListener = this.registerHistoryListener.bind(this);
-    }
+/**
+ * `IonReactMemoryRouter` provides a way to use `react-router` in
+ * environments where a traditional browser history (like `BrowserRouter`)
+ * isn't available or desirable.
+ */
+const RouterContent$1 = ({ children }) => {
+    const location = useLocation$1();
+    const navigationType = useNavigationType$1();
+    const historyListenHandler = useRef();
+    const registerHistoryListener = (cb) => {
+        historyListenHandler.current = cb;
+    };
     /**
-     * history@4.x passes separate location and action
-     * params. history@5.x passes location and action
-     * together as a single object.
-     * TODO: If support for React Router <=5 is dropped
-     * this logic is no longer needed. We can just assume
-     * a single object with both location and action.
+     * Processes navigation changes within the application.
+     *
+     * Its purpose is to relay the current `location` and the associated
+     * `action` ('PUSH', 'POP', or 'REPLACE') to any registered listeners,
+     * primarily for `IonRouter` to manage Ionic-specific UI updates and
+     * navigation stack behavior.
+     *
+     * @param location The current browser history location object.
+     * @param action The type of navigation action ('PUSH', 'POP', or
+     * 'REPLACE').
      */
-    handleHistoryChange(location, action) {
-        const locationValue = location.location || location;
-        const actionValue = location.action || action;
-        if (this.historyListenHandler) {
-            this.historyListenHandler(locationValue, actionValue);
+    const handleHistoryChange = (location, action) => {
+        if (historyListenHandler.current) {
+            historyListenHandler.current(location, action);
         }
-    }
-    registerHistoryListener(cb) {
-        this.historyListenHandler = cb;
-    }
-    render() {
-        const _a = this.props, { children } = _a, props = __rest(_a, ["children"]);
-        return (React.createElement(Router$1, Object.assign({}, props),
-            React.createElement(IonRouter, { registerHistoryListener: this.registerHistoryListener }, children)));
-    }
-}
+    };
+    useEffect(() => {
+        handleHistoryChange(location, navigationType);
+    }, [location, navigationType]);
+    return React.createElement(IonRouter, { registerHistoryListener: registerHistoryListener }, children);
+};
+const IonReactMemoryRouter = (_a) => {
+    var { children } = _a, routerProps = __rest(_a, ["children"]);
+    return (React.createElement(MemoryRouter, Object.assign({}, routerProps),
+        React.createElement(RouterContent$1, null, children)));
+};
 
-class IonReactHashRouter extends React.Component {
-    constructor(props) {
-        super(props);
-        const { history } = props, rest = __rest(props, ["history"]);
-        this.history = history || createHashHistory(rest);
-        this.history.listen(this.handleHistoryChange.bind(this));
-        this.registerHistoryListener = this.registerHistoryListener.bind(this);
-    }
+/**
+ * `IonReactHashRouter` provides a way to use hash-based routing in Ionic
+ * React applications.
+ */
+const RouterContent = ({ children }) => {
+    const location = useLocation();
+    const navigationType = useNavigationType();
+    const historyListenHandler = useRef();
+    const registerHistoryListener = (cb) => {
+        historyListenHandler.current = cb;
+    };
     /**
-     * history@4.x passes separate location and action
-     * params. history@5.x passes location and action
-     * together as a single object.
-     * TODO: If support for React Router <=5 is dropped
-     * this logic is no longer needed. We can just assume
-     * a single object with both location and action.
+     * Processes navigation changes within the application.
+     *
+     * Its purpose is to relay the current `location` and the associated
+     * `action` ('PUSH', 'POP', or 'REPLACE') to any registered listeners,
+     * primarily for `IonRouter` to manage Ionic-specific UI updates and
+     * navigation stack behavior.
+     *
+     * @param location The current browser history location object.
+     * @param action The type of navigation action ('PUSH', 'POP', or
+     * 'REPLACE').
      */
-    handleHistoryChange(location, action) {
-        const locationValue = location.location || location;
-        const actionValue = location.action || action;
-        if (this.historyListenHandler) {
-            this.historyListenHandler(locationValue, actionValue);
+    const handleHistoryChange = (location, action) => {
+        if (historyListenHandler.current) {
+            historyListenHandler.current(location, action);
         }
-    }
-    registerHistoryListener(cb) {
-        this.historyListenHandler = cb;
-    }
-    render() {
-        const _a = this.props, { children } = _a, props = __rest(_a, ["children"]);
-        return (React.createElement(Router, Object.assign({ history: this.history }, props),
-            React.createElement(IonRouter, { registerHistoryListener: this.registerHistoryListener }, children)));
-    }
-}
+    };
+    useEffect(() => {
+        handleHistoryChange(location, navigationType);
+    }, [location, navigationType]);
+    return React.createElement(IonRouter, { registerHistoryListener: registerHistoryListener }, children);
+};
+const IonReactHashRouter = (_a) => {
+    var { children } = _a, routerProps = __rest(_a, ["children"]);
+    return (React.createElement(HashRouter, Object.assign({}, routerProps),
+        React.createElement(RouterContent, null, children)));
+};
 
 export { IonReactHashRouter, IonReactMemoryRouter, IonReactRouter };
 //# sourceMappingURL=index.js.map