@ionic/react-router 8.8.1-dev.11773873479.192398dc → 8.8.1-dev.11773929121.1aabdf46

package/dist/index.js

@@ -1,1301 +1,176 @@
 import { __rest } from 'tslib';
-import React, { useRef, useState, useEffect, useCallback } from 'react';
-import { Route, matchPath as matchPath$1, Routes, Navigate, UNSAFE_RouteContext, matchRoutes, useLocation, useNavigate, BrowserRouter, useNavigationType, HashRouter } from 'react-router-dom';
-import { IonRoute, ViewStacks, generateId, ViewLifeCycleManager, StackContext, RouteManagerContext, getConfig, LocationHistory, NavManager } from '@ionic/react';
-import { MemoryRouter, useLocation as useLocation$1, useNavigationType as useNavigationType$1 } from 'react-router';
+import { createBrowserHistory, createHashHistory } from 'history';
+import React from 'react';
+import { withRouter, Router } 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';
 
-const IonRouteInner = ({ path, index, caseSensitive, element }) => {
-    return React.createElement(Route, { path: path, index: index, caseSensitive: caseSensitive, 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;
+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,
             }
-            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;
-};
+}
 
 /**
- * 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 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 pathname falls within the scope of a mount path using
- * segment-aware comparison. Prevents false positives like "/tabs-secondary"
- * matching mount path "/tabs".
+ * @see https://v5.reactrouter.com/web/api/matchPath
  */
-const isPathnameInScope = (pathname, mountPath) => {
-    if (mountPath === '/')
-        return true;
-    return pathname === mountPath || pathname.startsWith(mountPath + '/');
-};
-/**
- * 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 !!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)) {
+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) {
         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));
-};
-/**
- * Returns the first route that matches as a specific (non-wildcard, non-index) route.
- */
-const findFirstSpecificMatchingRoute = (routeChildren, remainingPath) => {
-    return routeChildren.find((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.
- *
- * Uses exact first-segment matching: the remaining path's first segment
- * must exactly equal a route's first segment to block the wildcard.
- * The outlet's mount path is always known from React Router's RouteContext,
- * so no heuristic-based discovery is needed.
- */
-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;
-        return routeFirstSegment === remainingFirstSegment;
-    });
-};
-/**
- * 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.
- *
- * When the mount path is known (seeded from React Router's RouteContext), the
- * parent path is simply the mount path — no iterative discovery needed. The
- * iterative fallback only runs for outlets where RouteContext doesn't provide
- * a parent match (typically root-level outlets on first render).
- *
- * @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.
-    // Use segment-aware comparison: /tabs-secondary must NOT match /tabs scope.
-    if (outletMountPath && !isPathnameInScope(currentPathname, outletMountPath)) {
-        return { parentPath: undefined, outletMountPath };
-    }
-    // Fast path: when the mount path is known (from React Router's RouteContext),
-    // the parent path IS the mount path. The iterative segment-by-segment discovery
-    // below was needed when the mount depth had to be guessed from URL structure,
-    // but with RouteContext we already know exactly where this outlet is mounted.
-    if (outletMountPath && (hasRelativeRoutes || hasIndexRoute)) {
-        return { parentPath: outletMountPath, outletMountPath };
-    }
-    // Fallback: mount path not yet known. Iterate through path segments to discover
-    // the correct parent depth. This only runs on first render of outlets where
-    // RouteContext doesn't provide a parent match (typically root-level outlets,
-    // which usually have absolute routes and take the absolute routes path below).
-    if (!outletMountPath && (hasRelativeRoutes || hasIndexRoute) && currentPathname.includes('/')) {
-        const segments = currentPathname.split('/').filter(Boolean);
-        if (segments.length >= 1) {
-            let firstSpecificMatch;
-            let firstWildcardMatch;
-            let indexMatchAtMount;
-            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)) {
-                    // Don't let empty/default path routes (path="" or undefined) drive
-                    // the parent deeper than a wildcard match. An empty path route matching
-                    // when remainingPath is "" just means all segments were consumed.
-                    if (firstWildcardMatch) {
-                        const matchingRoute = findFirstSpecificMatchingRoute(routeChildren, remainingPath);
-                        if (matchingRoute) {
-                            const matchingPath = matchingRoute.props.path;
-                            if (!matchingPath || matchingPath === '') {
-                                continue;
-                            }
-                        }
-                    }
-                    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
-                if ((remainingPath === '' || remainingPath === '/') && hasIndexRoute) {
-                    indexMatchAtMount = parentPath;
-                }
-            }
-            // 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);
-            return { parentPath: bestPath, outletMountPath: bestPath };
-        }
-    }
-    // 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 || child.type === IonRoute));
-};
-/**
- * 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')));
-};
-
-/**
- * Compares two routes by specificity for sorting (most specific first).
- *
- * Sort order:
- * 1. Index routes come first
- * 2. Wildcard-only routes (* or /*) come last
- * 3. Exact matches (no wildcards/params) before wildcard/param routes
- * 4. Among routes with same status, longer paths are more specific
- */
-const compareRouteSpecificity = (a, b) => {
-    // Index routes come first
-    if (a.index && !b.index)
-        return -1;
-    if (!a.index && b.index)
-        return 1;
-    // Wildcard-only routes (* or /*) should come last
-    const aIsWildcardOnly = a.path === '*' || a.path === '/*';
-    const bIsWildcardOnly = b.path === '*' || b.path === '/*';
-    if (!aIsWildcardOnly && bIsWildcardOnly)
-        return -1;
-    if (aIsWildcardOnly && !bIsWildcardOnly)
-        return 1;
-    // Exact matches (no wildcards/params) come before wildcard/param routes
-    const aHasWildcard = a.path.includes('*') || a.path.includes(':');
-    const bHasWildcard = b.path.includes('*') || b.path.includes(':');
-    if (!aHasWildcard && bHasWildcard)
-        return -1;
-    if (aHasWildcard && !bHasWildcard)
-        return 1;
-    // Among routes with same wildcard status, longer paths are more specific
-    if (a.path.length !== b.path.length) {
-        return b.path.length - a.path.length;
-    }
-    return 0;
-};
-/**
- * Sorts view items by route specificity (most specific first).
- *
- * Sort order aligns with findViewItemByPath in ReactRouterViewStack.tsx:
- * 1. Index routes come first
- * 2. Wildcard-only routes (* or /*) come last
- * 3. Exact matches (no wildcards/params) come before wildcard/param routes
- * 4. Among routes with same wildcard status, 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, _e, _f, _g, _h;
-        return compareRouteSpecificity({ path: ((_b = (_a = a.routeData) === null || _a === void 0 ? void 0 : _a.childProps) === null || _b === void 0 ? void 0 : _b.path) || '', index: !!((_d = (_c = a.routeData) === null || _c === void 0 ? void 0 : _c.childProps) === null || _d === void 0 ? void 0 : _d.index) }, { path: ((_f = (_e = b.routeData) === null || _e === void 0 ? void 0 : _e.childProps) === null || _f === void 0 ? void 0 : _f.path) || '', index: !!((_h = (_g = b.routeData) === null || _g === void 0 ? void 0 : _g.childProps) === null || _h === void 0 ? void 0 : _h.index) });
-    });
+    return match;
 };
 
-/**
- * `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 matchingViews = [];
-    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)) {
-                matchingViews.push({
-                    params: otherMatch.params,
-                    pathLength: matchedPathname.length,
-                });
-            }
-        }
-    }
-    // Sort ascending by path length so more-specific (longer) paths are applied
-    // last and their params take priority over less-specific ones.
-    matchingViews.sort((a, b) => a.pathLength - b.pathLength);
-    const params = {};
-    for (const view of matchingViews) {
-        Object.assign(params, view.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();
-        /**
-         * Stores the computed parent path for each outlet.
-         * Used by findViewItemByPath to correctly evaluate index route matches
-         * without requiring the outlet's React element or route children.
-         */
-        this.outletParentPaths = new Map();
-        /**
-         * Stores the computed mount path for each outlet.
-         * Fed back into computeParentPath on subsequent calls to stabilize
-         * the parent path computation across navigations (mirrors StackManager.outletMountPath).
-         */
-        this.outletMountPaths = new Map();
-        /**
-         * 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, this.outletParentPaths.get(outletId));
-                            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 (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, this.outletParentPaths.get(outletId)) ||
-                    ((_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 id = `${outletId}-${generateId(outletId)}`;
-            const viewItem = {
-                id,
-                outletId,
-                ionPageElement: page,
-                reactElement,
-                mount: true,
-                ionRoute: true,
-            };
-            if (reactElement.type === IonRoute) {
-                viewItem.disableIonPageManagement = reactElement.props.disableIonPageManagement;
-            }
-            const initialMatch = matchComponent$1(reactElement, routeInfo.pathname, true, this.outletParentPaths.get(outletId)) ||
-                createDefaultMatch(routeInfo.pathname, reactElement.props);
-            viewItem.routeData = {
-                match: initialMatch,
-                childProps: reactElement.props,
-            };
-            this.add(viewItem);
-            return viewItem;
+        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,
         };
-        /**
-         * 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, reRender) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
-            const routePath = viewItem.reactElement.props.path || '';
-            let match = matchComponent$1(viewItem.reactElement, routeInfo.pathname, false, parentPath);
-            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);
-                        reRender === null || reRender === void 0 ? void 0 : reRender();
-                    }, NAVIGATE_REDIRECT_DELAY_MS);
-                }
-            }
-            // 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);
-                            reRender === null || reRender === void 0 ? void 0 : reRender();
-                        }
-                    }, 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
-            // Don't reactivate catch-all wildcard routes — they are created fresh by createViewItem
-            const isCatchAllWildcard = routePath === '*' || routePath === '/*';
-            if (match && !viewItem.mount && !shouldSkipForDifferentParam && !isCatchAllWildcard) {
-                viewItem.mount = true;
-                viewItem.routeData.match = match;
-            }
-            // Deactivate wildcard (catch-all) and empty-path (default) routes when a more-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 outletViews = this.getViewItemsForOutlet(viewItem.outletId);
-                // When parent path context is available, compute the relative pathname once
-                // outside the loop since both routeInfo.pathname and parentPath are invariant.
-                const relativePathname = parentPath
-                    ? computeRelativeToParent(routeInfo.pathname, parentPath)
-                    : null;
-                let hasSpecificMatch = outletViews.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
-                    // When parent path context is available and the route is relative, use
-                    // parent-path-aware matching. This avoids false positives from
-                    // derivePathnameToMatch's tail-slice heuristic, which can incorrectly
-                    // match route literals that appear at the wrong position in the pathname.
-                    // Example: pathname /parent/extra/details/99 with route details/:id —
-                    // the tail-slice extracts ["details","99"] producing a false match.
-                    if (parentPath && vRoutePath && !vRoutePath.startsWith('/')) {
-                        if (relativePathname === null) {
-                            return false; // Pathname is outside this outlet's parent scope
-                        }
-                        return !!matchPath({
-                            pathname: relativePathname,
-                            componentProps: v.reactElement.props,
-                        });
-                    }
-                    // Fallback to matchComponent when no parent path context is available
-                    const vMatch = v.reactElement ? matchComponent$1(v.reactElement, routeInfo.pathname) : null;
-                    return !!vMatch;
-                });
-                // For catch-all * routes, also deactivate when the pathname matches the outlet's
-                // parent path exactly. This means there are no remaining segments for the wildcard
-                // to catch, so the empty-path or index route should handle it instead.
-                if (!hasSpecificMatch && routePath === '*') {
-                    const outletParentPath = this.outletParentPaths.get(viewItem.outletId);
-                    if (outletParentPath) {
-                        const normalizedParent = normalizePathnameForComparison(outletParentPath);
-                        const normalizedPathname = normalizePathnameForComparison(routeInfo.pathname);
-                        if (normalizedPathname === normalizedParent) {
-                            // Check if there's an empty-path or index view item that should handle this
-                            const hasDefaultRoute = outletViews.some((v) => {
-                                var _a, _b, _c, _d;
-                                if (v.id === viewItem.id)
-                                    return false;
-                                const vRoutePath = (_b = (_a = v.reactElement) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.path;
-                                return vRoutePath === '' || vRoutePath === undefined || !!((_d = (_c = v.routeData) === null || _c === void 0 ? void 0 : _c.childProps) === null || _d === void 0 ? void 0 : _d.index);
-                            });
-                            if (hasDefaultRoute) {
-                                hasSpecificMatch = true;
-                            }
-                        }
-                    }
-                }
-                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)));
-            }));
+        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,
         };
-        /**
-         * 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, reRender, parentPathnameBase) => {
-            const viewItems = this.getViewItemsForOutlet(outletId);
-            // Seed the mount path from the parent route context if available.
-            // This provides the outlet's mount path immediately on first render,
-            // eliminating the need for heuristic-based discovery in computeParentPath.
-            if (parentPathnameBase && !this.outletMountPaths.has(outletId)) {
-                this.outletMountPaths.set(outletId, parentPathnameBase);
-            }
-            // Determine parentPath for outlets with relative or index routes.
-            // This populates outletParentPaths for findViewItemByPath's matchView
-            // and the catch-all deactivation logic in renderViewItem.
-            let parentPath = undefined;
-            try {
-                const routeChildren = extractRouteChildren(ionRouterOutlet.props.children);
-                const { hasRelativeRoutes, hasIndexRoute, hasWildcardRoute } = analyzeRouteChildren(routeChildren);
-                if (hasRelativeRoutes || hasIndexRoute) {
-                    const result = computeParentPath({
-                        currentPathname: routeInfo.pathname,
-                        outletMountPath: this.outletMountPaths.get(outletId),
-                        routeChildren,
-                        hasRelativeRoutes,
-                        hasIndexRoute,
-                        hasWildcardRoute,
-                    });
-                    parentPath = result.parentPath;
-                    // Persist the mount path for subsequent calls, mirroring StackManager.outletMountPath.
-                    // Unlike outletParentPaths (cleared when parentPath is undefined), the mount path is
-                    // intentionally sticky — it anchors the outlet's scope and is only removed in clear().
-                    if (result.outletMountPath && !this.outletMountPaths.has(outletId)) {
-                        this.outletMountPaths.set(outletId, result.outletMountPath);
-                    }
-                }
-            }
-            catch (e) {
-                // Non-fatal: if we fail to compute parentPath, fall back to previous behavior
-            }
-            // Store the computed parentPath for use in findViewItemByPath.
-            // Clear stale entries when parentPath is undefined (e.g., navigated out of scope).
-            if (parentPath !== undefined) {
-                this.outletParentPaths.set(outletId, parentPath);
-            }
-            else if (this.outletParentPaths.has(outletId)) {
-                this.outletParentPaths.delete(outletId);
-            }
-            // 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;
+        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);
             });
-            // 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, false, parentPath);
-                        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);
-                                reRender();
-                            }, 0);
-                            return false;
-                        }
-                    }
-                }
-                return true;
-            });
-            const renderedItems = renderableViewItems.map((viewItem) => this.renderViewItem(viewItem, routeInfo, parentPath, reRender));
-            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;
+            if (viewItem) {
+                viewItem.reactElement = child;
             }
-            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);
-                });
+        });
+        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,
+                })));
             }
-        };
-        /**
-         * 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;
+            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;
+                    viewItem.mount = false;
+                }
             }
-            super.add(viewItem);
-            this.cleanupStaleViewItems(viewItem.outletId);
-        };
-        /**
-         * Override clear to also clean up the stored parent path for the outlet.
-         */
-        this.clear = (outletId) => {
-            this.outletParentPaths.delete(outletId);
-            this.outletMountPaths.delete(outletId);
-            return super.clear(outletId);
-        };
-        /**
-         * Override remove
-         */
-        this.remove = (viewItem) => {
-            super.remove(viewItem);
-        };
+            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;
     }
     /**
-     * Core function that matches a given pathname against all view items.
-     * Returns both the matched view item and match metadata.
+     * Returns the matching view item and the match result for a given pathname.
      */
-    findViewItemByPath(pathname, outletId, mustBeIonRoute, allowDefaultMatch = true) {
+    findViewItemByPath(pathname, outletId, mustBeIonRoute) {
         let viewItem;
-        let match = null;
+        let match;
         let viewStack;
-        // Capture stored parent paths for use in nested matchView/matchDefaultRoute functions
-        const storedParentPaths = this.outletParentPaths;
         if (outletId) {
-            viewStack = sortViewsBySpecificity(this.getViewItemsForOutlet(outletId));
+            viewStack = this.getViewItemsForOutlet(outletId);
             viewStack.some(matchView);
-            if (!viewItem && allowDefaultMatch)
+            if (!viewItem) {
                 viewStack.some(matchDefaultRoute);
+            }
         }
         else {
-            const viewItems = sortViewsBySpecificity(this.getAllViewItems());
+            const viewItems = this.getAllViewItems();
             viewItems.some(matchView);
-            if (!viewItem && allowDefaultMatch)
+            if (!viewItem) {
                 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;
-            if (mustBeIonRoute && !v.ionRoute)
-                return false;
-            const viewItemPath = v.routeData.childProps.path || '';
-            // Skip unmounted catch-all wildcard views. After back navigation unmounts
-            // a wildcard view, it should not be reused for subsequent navigations.
-            // A fresh wildcard view will be created by createViewItem when needed.
-            if ((viewItemPath === '*' || viewItemPath === '/*') && !v.mount)
+            var _a, _b;
+            if (mustBeIonRoute && !v.ionRoute) {
                 return false;
-            const isIndexRoute = !!v.routeData.childProps.index;
-            const previousMatch = (_a = v.routeData) === null || _a === void 0 ? void 0 : _a.match;
-            const outletParentPath = storedParentPaths.get(v.outletId);
-            const result = v.reactElement ? matchComponent$1(v.reactElement, pathname, false, outletParentPath) : null;
-            if (!result) {
-                const indexMatch = resolveIndexRouteMatch(v, pathname, outletParentPath);
-                if (indexMatch) {
-                    match = indexMatch;
-                    viewItem = v;
-                    return true;
-                }
-                // Empty path routes (path="") should match when the pathname matches the
-                // outlet's parent path exactly (no remaining segments). matchComponent doesn't
-                // handle this because it lacks parent path context. Without this check, a
-                // catch-all * view item (which matches any pathname) would be incorrectly
-                // returned instead of the empty path route on back navigation.
-                if (viewItemPath === '' && !isIndexRoute && outletParentPath) {
-                    const normalizedParent = normalizePathnameForComparison(outletParentPath);
-                    const normalizedPathname = normalizePathnameForComparison(pathname);
-                    if (normalizedPathname === normalizedParent) {
-                        match = createDefaultMatch(pathname, v.routeData.childProps);
-                        viewItem = v;
-                        return true;
-                    }
-                }
             }
-            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;
+            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))) {
                     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) {
-            var _a, _b, _c;
-            const childProps = v.routeData.childProps;
-            const isDefaultRoute = childProps.path === undefined || childProps.path === '';
-            const isIndexRoute = !!childProps.index;
-            if (isIndexRoute) {
-                const outletParentPath = storedParentPaths.get(v.outletId);
-                const indexMatch = resolveIndexRouteMatch(v, pathname, outletParentPath);
-                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;
-                }
+            // 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) {
                 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;
@@ -1304,40 +179,11 @@ class ReactRouterViewStack extends ViewStacks {
         }
     }
 }
-/**
- * Utility to apply matchPath to a React element and return its match state.
- */
-function matchComponent$1(node, pathname, allowFallback = false, parentPath) {
-    var _a;
-    const routeProps = (_a = node === null || node === void 0 ? void 0 : node.props) !== null && _a !== void 0 ? _a : {};
-    const routePath = routeProps.path;
-    let pathnameToMatch;
-    if (parentPath && routePath && !routePath.startsWith('/')) {
-        // When parent path is known, compute exact relative pathname
-        // instead of using the tail-slice heuristic
-        const relative = pathname.startsWith(parentPath)
-            ? pathname.slice(parentPath.length).replace(/^\//, '')
-            : pathname;
-        pathnameToMatch = relative;
-    }
-    else {
-        pathnameToMatch = derivePathnameToMatch(pathname, routePath);
-    }
-    const match = matchPath({
-        pathname: pathnameToMatch,
-        componentProps: routeProps,
+function matchComponent$1(node, pathname) {
+    return matchPath({
+        pathname,
+        componentProps: node.props,
     });
-    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) {
@@ -1362,37 +208,7 @@ function clonePageElement(leavingViewHtml) {
     return undefined;
 }
 
-/**
- * `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 (ms) to wait for an IonPage to mount before proceeding with a
- * page transition. Only container routes (nested outlets with no direct
- * IonPage) actually hit this timeout; normal routes clear it early via
- * registerIonPage, so a larger value here doesn't affect the happy path.
- */
-const ION_PAGE_WAIT_TIMEOUT_MS = 300;
-const isViewVisible = (el) => !el.classList.contains('ion-page-invisible') && !el.classList.contains('ion-page-hidden') && el.style.visibility !== 'hidden';
-const hideIonPageElement = (element) => {
-    if (element) {
-        element.classList.add('ion-page-hidden');
-        element.setAttribute('aria-hidden', 'true');
-    }
-};
-const showIonPageElement = (element) => {
-    if (element) {
-        element.style.removeProperty('visibility');
-        element.classList.remove('ion-page-hidden');
-        element.removeAttribute('aria-hidden');
-    }
-};
+const isViewVisible = (el) => !el.classList.contains('ion-page-invisible') && !el.classList.contains('ion-page-hidden');
 class StackManager extends React.PureComponent {
     constructor(props) {
         super(props);
@@ -1401,540 +217,14 @@ class StackManager extends React.PureComponent {
             isInOutlet: () => true,
         };
         this.pendingPageTransition = false;
-        this.waitingForIonPage = false;
-        /** Tracks whether the component is mounted to guard async transition paths. */
-        this._isMounted = false;
-        /** In-flight requestAnimationFrame IDs from transitionPage, cancelled on unmount. */
-        this.transitionRafIds = [];
-        this.outletMountPath = undefined;
-        /**
-         * Whether this outlet is at the root level (no parent route matches).
-         * Derived from UNSAFE_RouteContext in render() — empty matches means root.
-         */
-        this.isRootOutlet = true;
         this.registerIonPage = this.registerIonPage.bind(this);
         this.transitionPage = this.transitionPage.bind(this);
         this.handlePageTransition = this.handlePageTransition.bind(this);
-        this.id = props.id || `routerOutlet-${generateId('routerOutlet')}`;
+        this.id = generateId('routerOutlet');
         this.prevProps = undefined;
         this.skipTransition = false;
     }
-    /**
-     * Determines the parent path for nested routing in React Router 6.
-     *
-     * When the mount path is known (seeded from UNSAFE_RouteContext), returns
-     * it directly — no iterative discovery needed. The computeParentPath
-     * fallback only runs for root outlets where RouteContext doesn't provide
-     * a parent match.
-     */
-    getParentPath() {
-        const currentPathname = this.props.routeInfo.pathname;
-        // Prevent out-of-scope outlets from adopting unrelated routes.
-        // Uses segment-aware comparison: /tabs-secondary must NOT match /tabs scope.
-        if (this.outletMountPath && !isPathnameInScope(currentPathname, this.outletMountPath)) {
-            return undefined;
-        }
-        // Fast path: mount path is known from RouteContext. The parent path IS the
-        // mount path — no need to run the iterative computeParentPath algorithm.
-        if (this.outletMountPath && !this.isRootOutlet) {
-            return this.outletMountPath;
-        }
-        // Fallback: root outlet or mount path not yet seeded. Run the full
-        // computeParentPath algorithm to discover the parent depth.
-        if (this.ionRouterOutlet) {
-            const routeChildren = extractRouteChildren(this.ionRouterOutlet.props.children);
-            const { hasRelativeRoutes, hasIndexRoute, hasWildcardRoute } = analyzeRouteChildren(routeChildren);
-            if (!this.isRootOutlet || hasRelativeRoutes || hasIndexRoute) {
-                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 || isPathnameInScope(routeInfo.pathname, this.outletMountPath)) {
-            return false;
-        }
-        if (this.outOfScopeUnmountTimeout) {
-            clearTimeout(this.outOfScopeUnmountTimeout);
-            this.outOfScopeUnmountTimeout = undefined;
-        }
-        // Remove view items from the stack but do NOT apply ion-page-hidden.
-        // ion-page-hidden sets display:none which immediately removes content
-        // from the layout, causing the parent outlet's leaving page to flash
-        // blank during its transition animation (issue #25477).
-        //
-        // Removing from the stack triggers React reconciliation via forceUpdate,
-        // which removes the DOM elements. React batches this re-render after all
-        // componentDidUpdate calls in the current cycle, so the parent outlet's
-        // commit() captures the current DOM state (with content visible) before
-        // React processes the removal. The compositor's cached layer is unaffected
-        // by subsequent DOM changes during the animation.
-        const allViewsInOutlet = this.context.getViewItemsForOutlet(this.id);
-        allViewsInOutlet.forEach((viewItem) => {
-            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;
-        if (this.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 || child.type === IonRoute));
-        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) {
-        if (this.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, this.outletMountPath);
-                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, this.outletMountPath);
-                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 `visibility:hidden`.
-     *
-     * Skips transitions only for outlets nested inside a parent IonPage's content
-     * area (i.e., an ion-content sits between the outlet and the .ion-page). These
-     * outlets render child pages inside a parent page's scrollable area, and the MD
-     * animation shows both entering and leaving pages simultaneously — causing text
-     * overlap and nested scrollbars. Standard page-level outlets (tabs, routing,
-     * swipe-to-go-back) animate normally even though they sit inside a framework-
-     * managed .ion-page wrapper from the parent outlet's view stack.
-     *
-     * Uses inline visibility:hidden rather than ion-page-hidden class because
-     * core's beforeTransition() removes ion-page-hidden via setPageHidden().
-     * Inline visibility:hidden survives that removal, keeping the page hidden
-     * until React unmounts it after ionViewDidLeave fires. Unlike display:none,
-     * visibility:hidden preserves element geometry so commit() animations
-     * can resolve normally.
-     */
-    applySkipAnimationIfNeeded(enteringViewItem, leavingViewItem) {
-        var _a, _b;
-        // Only skip for outlets genuinely nested inside a page's content area.
-        // Walk from the outlet up to the nearest .ion-page; if an ion-content
-        // sits in between, the outlet is inside scrollable page content and
-        // animating would cause overlapping pages with duplicate scrollbars.
-        let isInsidePageContent = false;
-        let el = (_b = (_a = this.routerOutletElement) === null || _a === void 0 ? void 0 : _a.parentElement) !== null && _b !== void 0 ? _b : null;
-        while (el) {
-            if (el.classList.contains('ion-page'))
-                break;
-            if (el.tagName === 'ION-CONTENT') {
-                isInsidePageContent = true;
-                break;
-            }
-            el = el.parentElement;
-        }
-        const shouldSkip = isInsidePageContent && !!leavingViewItem && enteringViewItem !== leavingViewItem;
-        if (shouldSkip && (leavingViewItem === null || leavingViewItem === void 0 ? void 0 : leavingViewItem.ionPageElement)) {
-            leavingViewItem.ionPageElement.style.setProperty('visibility', 'hidden');
-            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();
-                // Safety net: after forceUpdate triggers a React render cycle, check if
-                // any pages in this outlet are stuck with ion-page-invisible. This can
-                // happen when view lookup fails (e.g., wildcard-to-index transitions
-                // where the view item gets corrupted). The forceUpdate above causes
-                // React to render the correct component, but ion-page-invisible may
-                // persist if no transition runs for that page.
-                setTimeout(() => {
-                    if (!this._isMounted || !this.routerOutletElement)
-                        return;
-                    const stuckPages = this.routerOutletElement.querySelectorAll(':scope > .ion-page-invisible');
-                    stuckPages.forEach((page) => {
-                        page.classList.remove('ion-page-invisible');
-                    });
-                }, ION_PAGE_WAIT_TIMEOUT_MS);
-            }
-        }, 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() {
-        this._isMounted = true;
         if (this.clearOutletTimeout) {
             /**
              * The clearOutlet integration with React Router is a bit hacky.
@@ -1965,186 +255,117 @@ class StackManager extends React.PureComponent {
         }
     }
     componentWillUnmount() {
-        this._isMounted = false;
-        // Cancel any in-flight transition rAFs
-        for (const id of this.transitionRafIds) {
-            cancelAnimationFrame(id);
-        }
-        this.transitionRafIds = [];
-        // Disconnect any in-flight MutationObserver from waitForComponentsReady
-        if (this.transitionObserver) {
-            this.transitionObserver.disconnect();
-            this.transitionObserver = undefined;
-        }
-        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;
-        // Wait for router outlet to mount
+        var _a, _b;
         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;
         }
-        // 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;
+        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);
             }
-            if (this.ionPageWaitTimeout) {
-                clearTimeout(this.ionPageWaitTimeout);
-                this.ionPageWaitTimeout = undefined;
+            // 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;
+                }
             }
-            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;
+            const enteringRoute = matchRoute((_b = this.ionRouterOutlet) === null || _b === void 0 ? void 0 : _b.props.children, routeInfo);
+            if (enteringViewItem) {
+                enteringViewItem.reactElement = enteringRoute;
             }
-            // Ensure the view is marked as mounted so ViewLifeCycleManager renders the IonPage
-            if (!enteringViewItem.mount) {
-                enteringViewItem.mount = true;
+            else if (enteringRoute) {
+                enteringViewItem = this.context.createViewItem(this.id, enteringRoute, routeInfo);
+                this.context.addViewItem(enteringViewItem);
             }
-            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;
+            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);
+            }
+            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');
+                }
+                // }, 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;
             /**
@@ -2158,32 +379,6 @@ 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();
@@ -2192,34 +387,40 @@ class StackManager extends React.PureComponent {
                 return false;
             }
             const { routeInfo } = this.props;
-            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 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 onStart = async () => {
             const { routeInfo } = this.props;
-            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 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 leavingViewItem = this.context.findViewItemByRouteInfo(routeInfo, this.id, false);
-            // 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
+            /**
+             * When the gesture starts, kick off
+             * a transition that is controlled
+             * via a swipe gesture.
+             */
             if (enteringViewItem && leavingViewItem) {
                 await this.transitionPage(routeInfo, enteringViewItem, leavingViewItem, 'back', true);
             }
@@ -2227,23 +428,34 @@ 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 {
-                // Swipe gesture was aborted - re-hide the page that was going to enter
+                /**
+                 * In the event that the swipe
+                 * gesture was aborted, we should
+                 * re-hide the page that was going to enter.
+                 */
                 const { routeInfo } = this.props;
-                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 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 leavingViewItem = this.context.findViewItemByRouteInfo(routeInfo, this.id, false);
-                // Don't hide if entering and leaving are the same (parameterized route edge case)
+                /**
+                 * 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.
+                 */
                 if (enteringViewItem !== leavingViewItem && (enteringViewItem === null || enteringViewItem === void 0 ? void 0 : enteringViewItem.ionPageElement) !== undefined) {
-                    hideIonPageElement(enteringViewItem.ionPageElement);
+                    const { ionPageElement } = enteringViewItem;
+                    ionPageElement.setAttribute('aria-hidden', 'true');
+                    ionPageElement.classList.add('ion-page-hidden');
                 }
             }
         };
@@ -2253,23 +465,7 @@ class StackManager extends React.PureComponent {
             onEnd,
         };
     }
-    /**
-     * 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) {
+    async transitionPage(routeInfo, enteringViewItem, leavingViewItem, direction, progressAnimation = false) {
         const runCommit = async (enteringEl, leavingEl) => {
             const skipTransition = this.skipTransition;
             /**
@@ -2297,43 +493,24 @@ class StackManager extends React.PureComponent {
             }
             else {
                 enteringEl.classList.add('ion-page');
-                /**
-                 * 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');
-                }
+                enteringEl.classList.add('ion-page-invisible');
             }
-            const commitDuration = skipTransition || skipAnimation || directionToUse === undefined ? 0 : undefined;
-            // Race commit against a timeout to recover from hangs
-            const commitPromise = routerOutlet.commit(enteringEl, leavingEl, {
-                duration: commitDuration,
+            await routerOutlet.commit(enteringEl, leavingEl, {
+                duration: skipTransition || directionToUse === undefined ? 0 : undefined,
                 direction: directionToUse,
                 showGoBack: !!routeInfo.pushedByRoute,
                 progressAnimation,
                 animationBuilder: routeInfo.routeAnimation,
             });
-            const timeoutMs = 5000;
-            const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve('timeout'), timeoutMs));
-            const result = await Promise.race([commitPromise.then(() => 'done'), timeoutPromise]);
-            if (result === 'timeout') {
-                // Force entering page visible even though commit hung
-                enteringEl.classList.remove('ion-page-invisible');
-            }
-            if (!progressAnimation) {
-                enteringEl.classList.remove('ion-page-invisible');
-            }
         };
         const routerOutlet = this.routerOutletElement;
         const routeInfoFallbackDirection = routeInfo.routeDirection === 'none' || routeInfo.routeDirection === 'root' ? undefined : routeInfo.routeDirection;
         const directionToUse = direction !== null && direction !== void 0 ? direction : routeInfoFallbackDirection;
         if (enteringViewItem && enteringViewItem.ionPageElement && this.routerOutletElement) {
             if (leavingViewItem && leavingViewItem.ionPageElement && enteringViewItem === leavingViewItem) {
-                // Clone page for same-view transitions (e.g., /user/1 → /user/2)
-                const match = matchComponent(leavingViewItem.reactElement, routeInfo.pathname, undefined, this.outletMountPath);
+                // 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);
                 if (match) {
                     const newLeavingElement = clonePageElement(leavingViewItem.ionPageElement.outerHTML);
                     if (newLeavingElement) {
@@ -2343,104 +520,14 @@ class StackManager extends React.PureComponent {
                     }
                 }
                 else {
-                    // Route no longer matches (e.g., /user/1 → /settings)
                     await runCommit(enteringViewItem.ionPageElement, undefined);
                 }
             }
             else {
-                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) {
-                    /**
-                     * Skip commit() for non-animated transitions (like tab switches).
-                     * commit() runs animation logic that can cause intermediate paints
-                     * even with duration: 0. Instead, swap visibility synchronously.
-                     *
-                     * Synchronous DOM class changes are batched into a single browser
-                     * paint, so there's no gap frame where neither page is visible and
-                     * no overlap frame where both pages are visible.
-                     */
-                    const enteringEl = enteringViewItem.ionPageElement;
-                    // Ensure entering element has proper base classes
-                    enteringEl.classList.add('ion-page');
-                    // Clear ALL hidden state from entering element. showIonPageElement
-                    // removes visibility:hidden (from applySkipAnimationIfNeeded),
-                    // ion-page-hidden, and aria-hidden in one call.
-                    showIonPageElement(enteringEl);
-                    // 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();
-                                    if (this.transitionObserver === observer) {
-                                        this.transitionObserver = undefined;
-                                    }
-                                    resolve();
-                                }
-                            });
-                            // Disconnect any previous observer before tracking the new one
-                            if (this.transitionObserver) {
-                                this.transitionObserver.disconnect();
-                            }
-                            this.transitionObserver = observer;
-                            observer.observe(enteringEl, {
-                                subtree: true,
-                                attributes: true,
-                                attributeFilter: ['class'],
-                            });
-                            setTimeout(() => {
-                                if (!resolved) {
-                                    resolved = true;
-                                    observer.disconnect();
-                                    if (this.transitionObserver === observer) {
-                                        this.transitionObserver = undefined;
-                                    }
-                                    resolve();
-                                }
-                            }, 100);
-                        });
-                    };
-                    await waitForComponentsReady();
-                    // Bail out if the component unmounted during waitForComponentsReady
-                    if (!this._isMounted)
-                        return;
-                    // Swap visibility synchronously - show entering, hide leaving
-                    enteringEl.classList.remove('ion-page-invisible');
-                    leavingEl.classList.add('ion-page-hidden');
-                    leavingEl.setAttribute('aria-hidden', 'true');
-                }
-                else {
-                    await runCommit(enteringViewItem.ionPageElement, leavingEl);
-                    if (leavingEl && !progressAnimation) {
-                        leavingEl.classList.add('ion-page-hidden');
-                        leavingEl.setAttribute('aria-hidden', 'true');
-                    }
+                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');
                 }
             }
         }
@@ -2448,494 +535,193 @@ 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;
-        return (React.createElement(UNSAFE_RouteContext.Consumer, null, (parentContext) => {
-            // Derive the outlet's mount path from React Router's matched route context.
-            // This eliminates the need for heuristic-based mount path discovery in
-            // computeParentPath, since React Router already knows the matched base path.
-            const parentMatches = parentContext === null || parentContext === void 0 ? void 0 : parentContext.matches;
-            const parentPathnameBase = parentMatches && parentMatches.length > 0
-                ? parentMatches[parentMatches.length - 1].pathnameBase
-                : undefined;
-            // Derive isRootOutlet from RouteContext: empty matches means root.
-            this.isRootOutlet = !parentMatches || parentMatches.length === 0;
-            // Seed StackManager's mount path from the parent route context
-            if (parentPathnameBase && !this.outletMountPath) {
-                this.outletMountPath = parentPathnameBase;
-            }
-            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();
-            }, parentPathnameBase);
-            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);
-                    }
-                },
-            }, components)));
-        }));
+        const components = this.context.getChildrenToRender(this.id, this.ionRouterOutlet, this.props.routeInfo, () => {
+            this.forceUpdate();
+        });
+        return (React.createElement(StackContext.Provider, { value: this.stackContextValue }, React.cloneElement(ionRouterOutlet, {
+            ref: (node) => {
+                if (ionRouterOutlet.props.setRef) {
+                    ionRouterOutlet.props.setRef(node);
+                }
+                if (ionRouterOutlet.props.forwardedRef) {
+                    ionRouterOutlet.props.forwardedRef.current = node;
+                }
+                this.routerOutletElement = node;
+                const { ref } = ionRouterOutlet;
+                if (typeof ref === 'function') {
+                    ref(node);
+                }
+            },
+        }, components)));
     }
     static get contextType() {
         return RouteManagerContext;
     }
 }
-/**
- * Converts React Route elements to RouteObject format for use with matchRoutes().
- * Filters out pathless routes (which are handled by fallback logic separately).
- *
- * When a basename is provided, absolute route paths are relativized by stripping
- * the basename prefix. This is necessary because matchRoutes() strips the basename
- * from the LOCATION pathname but not from route paths — absolute paths must be
- * made relative to the basename for matching to work correctly.
- *
- * @param routeChildren The flat array of Route/IonRoute elements from the outlet.
- * @param basename The resolved parent path (without trailing slash or `/*`) used to relativize absolute paths.
- */
-function routeElementsToRouteObjects(routeChildren, basename) {
-    return routeChildren
-        .filter((child) => child.props.path != null || child.props.index)
-        .map((child) => {
-        const handle = { _element: child };
-        let path = child.props.path;
-        // Relativize absolute paths by stripping the basename prefix
-        if (path && path.startsWith('/') && basename) {
-            if (path === basename) {
-                path = '';
-            }
-            else if (path.startsWith(basename + '/')) {
-                path = path.slice(basename.length + 1);
-            }
-        }
-        if (child.props.index) {
-            return {
-                index: true,
-                handle,
-                caseSensitive: child.props.caseSensitive || undefined,
-            };
+function matchRoute(node, routeInfo) {
+    let matchedNode;
+    React.Children.forEach(node, (child) => {
+        const match = matchPath({
+            pathname: routeInfo.pathname,
+            componentProps: child.props,
+        });
+        if (match) {
+            matchedNode = child;
         }
-        return {
-            path,
-            handle,
-            caseSensitive: child.props.caseSensitive || undefined,
-        };
     });
-}
-/**
- * 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, _b, _c;
-    let matchedNode;
-    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 || child.type === IonRoute));
-    // Delegate route matching to RR6's matchRoutes(), which handles specificity ranking internally.
-    const basename = parentPath ? stripTrailingSlash(parentPath.replace('/*', '')) : undefined;
-    const routeObjects = routeElementsToRouteObjects(routeChildren, basename);
-    const matches = matchRoutes(routeObjects, { pathname: routeInfo.pathname }, basename);
-    if (matches && matches.length > 0) {
-        const bestMatch = matches[matches.length - 1];
-        matchedNode = (_c = (_b = bestMatch.route.handle) === null || _b === void 0 ? void 0 : _b._element) !== null && _c !== void 0 ? _c : undefined;
+    if (matchedNode) {
+        return matchedNode;
     }
-    // Fallback: try pathless routes, but only if pathname is within scope.
-    if (!matchedNode) {
-        let pathnameInScope = true;
-        if (parentPath) {
-            pathnameInScope = isPathnameInScope(routeInfo.pathname, parentPath);
-        }
-        else {
-            const absolutePathRoutes = routeChildren.filter((r) => r.props.path && r.props.path.startsWith('/'));
-            if (absolutePathRoutes.length > 0) {
-                const absolutePaths = absolutePathRoutes.map((r) => r.props.path);
-                const commonPrefix = computeCommonPrefix(absolutePaths);
-                if (commonPrefix && commonPrefix !== '/') {
-                    pathnameInScope = routeInfo.pathname.startsWith(commonPrefix);
-                }
-            }
-        }
-        if (pathnameInScope) {
-            for (const child of routeChildren) {
-                if (!child.props.path) {
-                    fallbackNode = child;
-                    break;
-                }
-            }
+    // 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;
         }
-    }
-    return matchedNode !== null && matchedNode !== void 0 ? matchedNode : fallbackNode;
+    });
+    return matchedNode;
 }
-function matchComponent(node, pathname, forceExact, parentPath) {
-    var _a;
-    const routePath = (_a = node === null || node === void 0 ? void 0 : node.props) === null || _a === void 0 ? void 0 : _a.path;
-    let pathnameToMatch;
-    if (parentPath && routePath && !routePath.startsWith('/')) {
-        // When parent path is known, compute exact relative pathname
-        const relative = pathname.startsWith(parentPath)
-            ? pathname.slice(parentPath.length).replace(/^\//, '')
-            : pathname;
-        pathnameToMatch = relative;
-    }
-    else {
-        pathnameToMatch = derivePathnameToMatch(pathname, routePath);
-    }
+function matchComponent(node, pathname, forceExact) {
     return matchPath({
-        pathname: pathnameToMatch,
-        componentProps: Object.assign(Object.assign({}, node.props), { end: forceExact }),
+        pathname,
+        componentProps: Object.assign(Object.assign({}, node.props), { exact: forceExact }),
     });
 }
 
-/**
- * `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;
-        }
-    }
-    return result;
-};
-/**
- * Checks if a POP event is a multi-step back navigation (navigate(-n) where n > 1).
- * Walks the pushedByRoute chain from prevInfo to verify the destination is an ancestor
- * in the same navigation chain. This distinguishes multi-step back from tab-crossing
- * back navigation where prevInfo.pathname also differs from the browser destination.
- */
-const checkIsMultiStepBack = (prevInfo, destinationPathname, history) => {
-    if (!prevInfo || prevInfo.pathname === destinationPathname)
-        return false;
-    const visited = new Set();
-    let walker = prevInfo;
-    while (walker === null || walker === void 0 ? void 0 : walker.pushedByRoute) {
-        if (visited.has(walker.id))
-            break; // cycle guard
-        visited.add(walker.id);
-        if (walker.pushedByRoute === destinationPathname)
-            return true;
-        walker = history.findLastLocation(walker);
-    }
-    return false;
-};
-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;
+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,
+        };
     }
-    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) {
+    handleChangeTab(tab, path, routeOptions) {
+        if (!path) {
             return;
         }
-        // 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);
-        // If IonTabBar already called handleSetCurrentTab during render (before this
-        // effect), the tab was stored in currentTab.current but the history entry was
-        // not yet seeded. Apply the pending tab to the seed entry now.
-        if (currentTab.current) {
-            const ri = Object.assign({}, locationHistory.current.current());
-            if (ri.tab !== currentTab.current) {
-                ri.tab = currentTab.current;
-                locationHistory.current.update(ri);
+        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 || ''));
             }
-        }
-        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;
+            else {
+                this.incomingRouteParams.pathname = pathname;
+                this.incomingRouteParams.search = search ? '?' + search : undefined;
+                this.incomingRouteParams.routeOptions = routeOptions;
+                this.props.history.push(pathname + (search ? '?' + search : ''));
             }
-            const updatedRouteInfo = Object.assign(Object.assign({}, routeInfo), { params: paramsCopy });
-            locationHistory.current.update(updatedRouteInfo);
-            setRouteInfo(updatedRouteInfo);
         }
-    }, [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;
+        else {
+            this.handleNavigate(pathname, 'push', 'none', undefined, routeOptions, tab);
+        }
+    }
+    handleHistoryChange(location, action) {
+        var _a, _b, _c;
         let leavingLocationInfo;
-        /**
-         * 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();
+        if (this.incomingRouteParams) {
+            if (this.incomingRouteParams.routeAction === 'replace') {
+                leavingLocationInfo = this.locationHistory.previous();
             }
             else {
-                // If the action is 'push' or 'pop', we want to use the current route.
-                leavingLocationInfo = locationHistory.current.current();
+                leavingLocationInfo = this.locationHistory.current();
             }
         }
         else {
-            /**
-             * 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();
+            leavingLocationInfo = this.locationHistory.current();
         }
         const leavingUrl = leavingLocationInfo.pathname + leavingLocationInfo.search;
-        if (leavingUrl !== location.pathname + location.search) {
-            if (!incomingRouteParams.current) {
-                // Use history-based tab detection instead of URL-pattern heuristics,
-                // so tab routes work with any URL structure (not just paths containing "/tabs").
-                // Fall back to currentTab.current only when the destination is within the
-                // current tab's path hierarchy (prevents non-tab routes from inheriting a tab).
-                let tabToUse = locationHistory.current.findTabForPathname(location.pathname);
-                if (!tabToUse && currentTab.current) {
-                    const tabFirstRoute = locationHistory.current.getFirstRouteInfoForTab(currentTab.current);
-                    const tabRootPath = tabFirstRoute === null || tabFirstRoute === void 0 ? void 0 : tabFirstRoute.pathname;
-                    if (tabRootPath && (location.pathname === tabRootPath || location.pathname.startsWith(tabRootPath + '/'))) {
-                        tabToUse = currentTab.current;
-                    }
-                }
-                /**
-                 * A `REPLACE` action can be triggered by React Router's
-                 * `<Navigate />` component.
-                 */
+        if (leavingUrl !== location.pathname) {
+            if (!this.incomingRouteParams) {
                 if (action === 'REPLACE') {
-                    incomingRouteParams.current = {
+                    this.incomingRouteParams = {
                         routeAction: 'replace',
                         routeDirection: 'none',
-                        tab: tabToUse,
+                        tab: this.currentTab,
                     };
                 }
-                /**
-                 * 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 = 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);
-                        const isMultiStepBack = checkIsMultiStepBack(prevInfo, location.pathname, locationHistory.current);
-                        if (isMultiStepBack) {
-                            const destinationInfo = locationHistory.current.findLastLocationByPathname(location.pathname);
-                            incomingRouteParams.current = Object.assign(Object.assign({}, (destinationInfo || {})), { routeAction: 'pop', routeDirection: 'back' });
-                        }
-                        else if (prevInfo && prevInfo.pathname !== location.pathname && currentRoute.tab) {
-                            // Browser POP destination differs from within-tab back target.
-                            // Sync URL via replace, like handleNavigateBack's non-linear path (#25141).
-                            incomingRouteParams.current = Object.assign(Object.assign({}, prevInfo), { routeAction: 'pop', routeDirection: 'back' });
-                            forwardStack.current = [];
-                            handleNavigate(prevInfo.pathname + (prevInfo.search || ''), 'pop', 'back', undefined, undefined, prevInfo.tab);
-                            return;
-                        }
-                        else {
-                            incomingRouteParams.current = Object.assign(Object.assign({}, prevInfo), { routeAction: 'pop', routeDirection: 'back' });
-                        }
+                    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' });
                     }
                     else {
-                        // It's a non-linear history path like a direct link.
-                        // Still push the current location key so browser forward is detectable.
-                        forwardStack.current.push(currentLocationKeyRef.current);
-                        incomingRouteParams.current = {
+                        this.incomingRouteParams = {
                             routeAction: 'pop',
                             routeDirection: 'none',
-                            tab: tabToUse,
+                            tab: this.currentTab,
                         };
                     }
                 }
-                if (!incomingRouteParams.current) {
-                    const state = location.state;
-                    incomingRouteParams.current = {
+                if (!this.incomingRouteParams) {
+                    this.incomingRouteParams = {
                         routeAction: 'push',
-                        routeDirection: (state === null || state === void 0 ? void 0 : state.direction) || 'forward',
-                        routeOptions: state === null || state === void 0 ? void 0 : state.routerOptions,
-                        tab: tabToUse,
+                        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,
                     };
                 }
             }
-            // New navigation (PUSH) invalidates browser forward history,
-            // so clear our forward stack to stay in sync.
-            if (action === 'PUSH') {
-                forwardStack.current = [];
-            }
             let routeInfo;
-            // If we're navigating away from tabs to a non-tab route, clear the current tab
-            if (!locationHistory.current.findTabForPathname(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.
-                 */
+            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);
             }
             else {
-                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 });
+                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 });
                 if (isPushed) {
-                    // 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;
-                }
-                else if (routeInfo.routeAction === 'push' &&
-                    routeInfo.routeDirection === 'none' &&
-                    routeInfo.tab === leavingLocationInfo.tab) {
-                    // Push with routerDirection="none" within the same tab (or non-tab) context.
-                    // Still needs pushedByRoute so the back button can navigate back correctly.
-                    // Cross-tab navigations with direction "none" are handled by the tab-switching
-                    // block below which has different pushedByRoute semantics.
-                    routeInfo.tab = routeInfo.tab || leavingLocationInfo.tab;
+                    routeInfo.tab = leavingLocationInfo.tab;
                     routeInfo.pushedByRoute = leavingLocationInfo.pathname;
                 }
                 else if (routeInfo.routeAction === 'pop') {
-                    // Triggered by a browser back button or handleNavigateBack.
-                    // Find the route that pushed this one.
-                    const r = locationHistory.current.findLastLocation(routeInfo);
+                    const r = this.locationHistory.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 = 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.
+                    // 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;
                 }
                 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();
                     /**
-                     * 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.
+                     * 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
@@ -2953,120 +739,46 @@ const IonRouter = ({ children, registerHistoryListener }) => {
                     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);
                 }
-                locationHistory.current.add(routeInfo);
+                this.locationHistory.add(routeInfo);
             }
-            setRouteInfo(routeInfo);
-        }
-        // 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;
-    };
-    /**
-     * 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.
-     */
-    const handleResetTab = (tab, originalHref, originalRouteOptions) => {
-        const routeInfo = locationHistory.current.getFirstRouteInfoForTab(tab);
-        if (routeInfo) {
-            const [pathname, search] = originalHref.split('?');
-            const newRouteInfo = Object.assign({}, routeInfo);
-            newRouteInfo.pathname = pathname;
-            newRouteInfo.search = search ? '?' + search : '';
-            newRouteInfo.routeOptions = originalRouteOptions;
-            incomingRouteParams.current = Object.assign(Object.assign({}, newRouteInfo), { routeAction: 'pop', routeDirection: 'back' });
-            navigate(newRouteInfo.pathname + (newRouteInfo.search || ''));
+            this.setState({
+                routeInfo,
+            });
         }
-    };
+        this.incomingRouteParams = undefined;
+    }
     /**
-     * Handles tab changes.
-     *
-     * @param tab The tab to switch to.
-     * @param path The new path for the tab.
-     * @param routeOptions Additional route options.
+     * 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 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) {
-                const newSearch = search ? '?' + search : routeInfo.search;
-                incomingRouteParams.current = Object.assign(Object.assign({}, routeParams), { search: newSearch || '', routeOptions });
-                navigate(routeInfo.pathname + (newSearch || ''));
-                /**
-                 * 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 : '', routeOptions });
-                navigate(pathname + (search ? '?' + search : ''));
-            }
-            // User has not navigated to this tab before.
+    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);
         }
         else {
-            const fullPath = pathname + (search ? '?' + search : '');
-            handleNavigate(fullPath, 'push', 'none', undefined, routeOptions, tab);
-        }
-    };
-    /**
-     * 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, _routeInfo) => {
-        currentTab.current = tab;
-        const current = locationHistory.current.current();
-        if (!current) {
-            // locationHistory not yet seeded (e.g., called during initial render
-            // before mount effect). The mount effect will seed the correct entry.
-            return;
-        }
-        const ri = Object.assign({}, current);
-        if (ri.tab !== tab) {
-            ri.tab = tab;
-            locationHistory.current.update(ri);
+            this.props.history.replace(path);
         }
-    };
-    /**
-     * 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) => {
+    }
+    handleNavigateBack(defaultHref = '/', routeAnimation) {
         const config = getConfig();
         defaultHref = defaultHref ? defaultHref : config && config.get('backButtonDefaultHref');
-        const routeInfo = locationHistory.current.current();
-        // It's a linear navigation.
+        const routeInfo = this.locationHistory.current();
         if (routeInfo && routeInfo.pushedByRoute) {
-            const prevInfo = locationHistory.current.findLastLocation(routeInfo);
+            const prevInfo = this.locationHistory.findLastLocation(routeInfo);
             if (prevInfo) {
                 /**
                  * This needs to be passed to handleNavigate
@@ -3074,243 +786,160 @@ const IonRouter = ({ children, registerHistoryListener }) => {
                  * will be overridden.
                  */
                 const incomingAnimation = routeAnimation || routeInfo.routeAnimation;
-                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.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 === '')) {
                     /**
-                     * 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.
+                     * 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.
                      */
-                    forwardStack.current = [];
-                    handleNavigate(prevInfo.pathname + (prevInfo.search || ''), 'pop', 'back', incomingAnimation);
+                    const history = this.props.history;
+                    const goBack = history.goBack || history.back;
+                    goBack();
+                }
+                else {
+                    this.handleNavigate(prevInfo.pathname + (prevInfo.search || ''), 'pop', 'back', incomingAnimation);
                 }
-                /**
-                 * `pushedByRoute` exists, but no corresponding previous entry in
-                 * the history stack.
-                 */
             }
             else {
-                handleNavigate(defaultHref, 'pop', 'back', routeAnimation);
+                this.handleNavigate(defaultHref, 'pop', 'back', routeAnimation);
             }
-            /**
-             * No `pushedByRoute` (e.g., initial page load or tab root).
-             * Tabs with no back history should not navigate.
-             */
         }
         else {
-            if (routeInfo && routeInfo.tab) {
-                return;
-            }
-            handleNavigate(defaultHref, 'pop', 'back', routeAnimation);
+            this.handleNavigate(defaultHref, 'pop', 'back', routeAnimation);
         }
-    };
-    /**
-     * 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.
-        // Uses history-based tab detection instead of URL pattern matching,
-        // so it works with any tab URL structure.
-        if (!tab && currentTab.current && path) {
-            // Check if destination was previously visited in a tab context
-            const destinationTab = locationHistory.current.findTabForPathname(path);
-            if (destinationTab) {
-                // Previously visited as a tab route - use the known tab
-                navigationTab = destinationTab;
-            }
-            else {
-                // New destination - check if it's a child of the current tab's root path
-                const tabFirstRoute = locationHistory.current.getFirstRouteInfoForTab(currentTab.current);
-                if (tabFirstRoute) {
-                    const tabRootPath = tabFirstRoute.pathname;
-                    if (path === tabRootPath || path.startsWith(tabRootPath + '/')) {
-                        // Still within the current tab's path hierarchy
-                        navigationTab = currentTab.current;
-                    }
-                    else {
-                        // Destination is outside the current tab context
-                        currentTab.current = undefined;
-                        navigationTab = undefined;
-                    }
-                }
-            }
+    }
+    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 || ''));
         }
-        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)));
-};
+    }
+    handleSetCurrentTab(tab) {
+        this.currentTab = tab;
+        const ri = Object.assign({}, this.locationHistory.current());
+        if (ri.tab !== tab) {
+            ri.tab = tab;
+            this.locationHistory.update(ri);
+        }
+    }
+    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);
 IonRouter.displayName = 'IonRouter';
 
-/**
- * `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;
-    }, []);
+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);
+    }
     /**
-     * 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').
+     * 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.
      */
-    const handleHistoryChange = useCallback((loc, act) => {
-        if (historyListenHandler.current) {
-            historyListenHandler.current(loc, act);
+    handleHistoryChange(location, action) {
+        const locationValue = location.location || location;
+        const actionValue = location.action || action;
+        if (this.historyListenHandler) {
+            this.historyListenHandler(locationValue, actionValue);
         }
-    }, []);
-    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)));
-};
+    }
+    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)));
+    }
+}
 
-/**
- * `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 = useCallback((cb) => {
-        historyListenHandler.current = cb;
-    }, []);
+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);
+    }
     /**
-     * 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').
+     * 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.
      */
-    const handleHistoryChange = useCallback((loc, act) => {
-        if (historyListenHandler.current) {
-            historyListenHandler.current(loc, act);
+    handleHistoryChange(location, action) {
+        const locationValue = location.location || location;
+        const actionValue = location.action || action;
+        if (this.historyListenHandler) {
+            this.historyListenHandler(locationValue, actionValue);
         }
-    }, []);
-    useEffect(() => {
-        handleHistoryChange(location, navigationType);
-    }, [location, navigationType, handleHistoryChange]);
-    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)));
-};
+    }
+    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)));
+    }
+}
 
-/**
- * `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 = useCallback((cb) => {
-        historyListenHandler.current = cb;
-    }, []);
+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);
+    }
     /**
-     * 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').
+     * 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.
      */
-    const handleHistoryChange = useCallback((loc, act) => {
-        if (historyListenHandler.current) {
-            historyListenHandler.current(loc, act);
+    handleHistoryChange(location, action) {
+        const locationValue = location.location || location;
+        const actionValue = location.action || action;
+        if (this.historyListenHandler) {
+            this.historyListenHandler(locationValue, actionValue);
         }
-    }, []);
-    useEffect(() => {
-        handleHistoryChange(location, navigationType);
-    }, [location, navigationType, handleHistoryChange]);
-    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)));
-};
+    }
+    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)));
+    }
+}
 
 export { IonReactHashRouter, IonReactMemoryRouter, IonReactRouter };
 //# sourceMappingURL=index.js.map