@angular/router 16.0.0-next.4 → 16.0.0-next.5

package/{fesm2020 → fesm2022}/router.mjs

@@ -1,15 +1,15 @@
 /**
- * @license Angular v16.0.0-next.4
+ * @license Angular v16.0.0-next.5
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
 
 import * as i0 from '@angular/core';
-import { ɵisPromise, ɵRuntimeError, Injectable, EventEmitter, inject, ViewContainerRef, ChangeDetectorRef, EnvironmentInjector, Directive, Input, Output, Component, createEnvironmentInjector, ɵisNgModule, isStandalone, ɵisInjectable, InjectionToken, Compiler, InjectFlags, NgModuleFactory, ɵConsole, NgZone, ɵcoerceToBoolean, ɵɵsanitizeUrlOrResourceUrl, Attribute, HostBinding, HostListener, Optional, ContentChildren, makeEnvironmentProviders, APP_BOOTSTRAP_LISTENER, ENVIRONMENT_INITIALIZER, Injector, ApplicationRef, APP_INITIALIZER, NgProbeToken, SkipSelf, NgModule, Inject, Version } from '@angular/core';
-import { isObservable, from, of, BehaviorSubject, EmptyError, combineLatest, concat, defer, pipe, throwError, Observable, EMPTY, ConnectableObservable, Subject } from 'rxjs';
+import { ɵisPromise, ɵRuntimeError, Injectable, EventEmitter, inject, ViewContainerRef, ChangeDetectorRef, EnvironmentInjector, Directive, Input, Output, Component, createEnvironmentInjector, ɵisNgModule, isStandalone, ɵisInjectable, InjectionToken, Compiler, InjectFlags, NgModuleFactory, ɵConsole, ɵInitialRenderPendingTasks, NgZone, ɵcoerceToBoolean, ɵɵsanitizeUrlOrResourceUrl, Attribute, HostBinding, HostListener, Optional, ContentChildren, makeEnvironmentProviders, APP_BOOTSTRAP_LISTENER, ENVIRONMENT_INITIALIZER, Injector, ApplicationRef, APP_INITIALIZER, NgProbeToken, SkipSelf, NgModule, Inject, Version } from '@angular/core';
+import { isObservable, from, of, BehaviorSubject, EmptyError, combineLatest, concat, defer, pipe, throwError, EMPTY, ConnectableObservable, Subject } from 'rxjs';
 import * as i3 from '@angular/common';
 import { Location, ViewportScroller, LOCATION_INITIALIZED, LocationStrategy, HashLocationStrategy, PathLocationStrategy } from '@angular/common';
-import { map, switchMap, take, startWith, filter, mergeMap, first, concatMap, tap, catchError, scan, last as last$1, takeWhile, defaultIfEmpty, takeLast, mapTo, finalize, refCount, mergeAll } from 'rxjs/operators';
+import { map, switchMap, take, startWith, filter, mergeMap, first, concatMap, tap, catchError, scan, defaultIfEmpty, last as last$1, takeLast, mapTo, finalize, refCount, mergeAll } from 'rxjs/operators';
 import * as i1 from '@angular/platform-browser';
 
 /**
@@ -162,7 +162,6 @@ function wrapIntoObservable(value) {
     return of(value);
 }
 
-const NG_DEV_MODE$a = typeof ngDevMode === 'undefined' || ngDevMode;
 const pathCompareMap = {
     'exact': equalSegmentGroups,
     'subset': containsSegmentGroup,
@@ -287,7 +286,7 @@ class UrlTree {
         this.root = root;
         this.queryParams = queryParams;
         this.fragment = fragment;
-        if (NG_DEV_MODE$a) {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
             if (root.segments.length > 0) {
                 throw new ɵRuntimeError(4015 /* RuntimeErrorCode.INVALID_ROOT_URL_SEGMENT */, 'The root `UrlSegmentGroup` should not contain `segments`. ' +
                     'Instead, these segments belong in the `children` so they can be associated with a named outlet.');
@@ -420,10 +419,10 @@ function mapChildrenIntoArray(segment, fn) {
  * @publicApi
  */
 class UrlSerializer {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: UrlSerializer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: UrlSerializer, providedIn: 'root', useFactory: () => new DefaultUrlSerializer() }); }
 }
-UrlSerializer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: UrlSerializer, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-UrlSerializer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: UrlSerializer, providedIn: 'root', useFactory: () => new DefaultUrlSerializer() });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: UrlSerializer, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: UrlSerializer, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root', useFactory: () => new DefaultUrlSerializer() }]
         }] });
@@ -635,7 +634,8 @@ class UrlParser {
     parseSegment() {
         const path = matchSegments(this.remaining);
         if (path === '' && this.peekStartsWith(';')) {
-            throw new ɵRuntimeError(4009 /* RuntimeErrorCode.EMPTY_PATH_WITH_PARAMS */, NG_DEV_MODE$a && `Empty path url segment cannot have parameters: '${this.remaining}'.`);
+            throw new ɵRuntimeError(4009 /* RuntimeErrorCode.EMPTY_PATH_WITH_PARAMS */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                `Empty path url segment cannot have parameters: '${this.remaining}'.`);
         }
         this.capture(path);
         return new UrlSegment(decode(path), this.parseMatrixParams());
@@ -704,7 +704,7 @@ class UrlParser {
             // if is is not one of these characters, then the segment was unescaped
             // or the group was not closed
             if (next !== '/' && next !== ')' && next !== ';') {
-                throw new ɵRuntimeError(4010 /* RuntimeErrorCode.UNPARSABLE_URL */, NG_DEV_MODE$a && `Cannot parse url '${this.url}'`);
+                throw new ɵRuntimeError(4010 /* RuntimeErrorCode.UNPARSABLE_URL */, (typeof ngDevMode === 'undefined' || ngDevMode) && `Cannot parse url '${this.url}'`);
             }
             let outletName = undefined;
             if (path.indexOf(':') > -1) {
@@ -735,7 +735,7 @@ class UrlParser {
     }
     capture(str) {
         if (!this.consumeOptional(str)) {
-            throw new ɵRuntimeError(4011 /* RuntimeErrorCode.UNEXPECTED_VALUE_IN_URL */, NG_DEV_MODE$a && `Expected "${str}".`);
+            throw new ɵRuntimeError(4011 /* RuntimeErrorCode.UNEXPECTED_VALUE_IN_URL */, (typeof ngDevMode === 'undefined' || ngDevMode) && `Expected "${str}".`);
         }
     }
 }
@@ -745,17 +745,28 @@ function createRoot(rootCandidate) {
         rootCandidate;
 }
 /**
- * Recursively merges primary segment children into their parents and also drops empty children
- * (those which have no segments and no children themselves). The latter prevents serializing a
- * group into something like `/a(aux:)`, where `aux` is an empty child segment.
+ * Recursively
+ * - merges primary segment children into their parents
+ * - drops empty children (those which have no segments and no children themselves). This latter
+ * prevents serializing a group into something like `/a(aux:)`, where `aux` is an empty child
+ * segment.
+ * - merges named outlets without a primary segment sibling into the children. This prevents
+ * serializing a URL like `//(a:a)(b:b) instead of `/(a:a//b:b)` when the aux b route lives on the
+ * root but the `a` route lives under an empty path primary route.
  */
 function squashSegmentGroup(segmentGroup) {
     const newChildren = {};
     for (const childOutlet of Object.keys(segmentGroup.children)) {
         const child = segmentGroup.children[childOutlet];
         const childCandidate = squashSegmentGroup(child);
-        // don't add empty children
-        if (childCandidate.segments.length > 0 || childCandidate.hasChildren()) {
+        // moves named children in an empty path primary child into this group
+        if (childOutlet === PRIMARY_OUTLET && childCandidate.segments.length === 0 &&
+            childCandidate.hasChildren()) {
+            for (const [grandChildOutlet, grandChild] of Object.entries(childCandidate.children)) {
+                newChildren[grandChildOutlet] = grandChild;
+            }
+        } // don't add empty children
+        else if (childCandidate.segments.length > 0 || childCandidate.hasChildren()) {
             newChildren[childOutlet] = childCandidate;
         }
     }
@@ -781,7 +792,6 @@ function isUrlTree(v) {
     return v instanceof UrlTree;
 }
 
-const NG_DEV_MODE$9 = typeof ngDevMode === 'undefined' || ngDevMode;
 /**
  * Creates a `UrlTree` relative to an `ActivatedRouteSnapshot`.
  *
@@ -928,11 +938,13 @@ class Navigation {
         this.numberOfDoubleDots = numberOfDoubleDots;
         this.commands = commands;
         if (isAbsolute && commands.length > 0 && isMatrixParams(commands[0])) {
-            throw new ɵRuntimeError(4003 /* RuntimeErrorCode.ROOT_SEGMENT_MATRIX_PARAMS */, NG_DEV_MODE$9 && 'Root segment cannot have matrix parameters');
+            throw new ɵRuntimeError(4003 /* RuntimeErrorCode.ROOT_SEGMENT_MATRIX_PARAMS */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                'Root segment cannot have matrix parameters');
         }
         const cmdWithOutlet = commands.find(isCommandWithOutlets);
         if (cmdWithOutlet && cmdWithOutlet !== last(commands)) {
-            throw new ɵRuntimeError(4004 /* RuntimeErrorCode.MISPLACED_OUTLETS_COMMAND */, NG_DEV_MODE$9 && '{outlets:{}} has to be the last command');
+            throw new ɵRuntimeError(4004 /* RuntimeErrorCode.MISPLACED_OUTLETS_COMMAND */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                '{outlets:{}} has to be the last command');
         }
     }
     toRoot() {
@@ -1016,7 +1028,7 @@ function createPositionApplyingDoubleDots(group, index, numberOfDoubleDots) {
         dd -= ci;
         g = g.parent;
         if (!g) {
-            throw new ɵRuntimeError(4005 /* RuntimeErrorCode.INVALID_DOUBLE_DOTS */, NG_DEV_MODE$9 && 'Invalid number of \'../\'');
+            throw new ɵRuntimeError(4005 /* RuntimeErrorCode.INVALID_DOUBLE_DOTS */, (typeof ngDevMode === 'undefined' || ngDevMode) && 'Invalid number of \'../\'');
         }
         ci = g.segments.length;
     }
@@ -1881,9 +1893,8 @@ class ActivatedRoute {
         this.data = data;
         this.outlet = outlet;
         this.component = component;
-        /** An Observable of the resolved route title */
-        this.title = this.data?.pipe(map((d) => d[RouteTitleKey])) ?? of(undefined);
         this._futureSnapshot = futureSnapshot;
+        this.title = this.data?.pipe(map((d) => d[RouteTitleKey])) ?? of(undefined);
     }
     /** The configuration used to match this route. */
     get routeConfig() {
@@ -2302,15 +2313,14 @@ class ChildrenOutletContexts {
     getContext(childName) {
         return this.contexts.get(childName) || null;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: ChildrenOutletContexts, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: ChildrenOutletContexts, providedIn: 'root' }); }
 }
-ChildrenOutletContexts.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: ChildrenOutletContexts, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ChildrenOutletContexts.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: ChildrenOutletContexts, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: ChildrenOutletContexts, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: ChildrenOutletContexts, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
-const NG_DEV_MODE$8 = typeof ngDevMode === 'undefined' || ngDevMode;
 /**
  * @description
  *
@@ -2449,12 +2459,12 @@ class RouterOutlet {
      */
     get component() {
         if (!this.activated)
-            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$8 && 'Outlet is not activated');
+            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, (typeof ngDevMode === 'undefined' || ngDevMode) && 'Outlet is not activated');
         return this.activated.instance;
     }
     get activatedRoute() {
         if (!this.activated)
-            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$8 && 'Outlet is not activated');
+            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, (typeof ngDevMode === 'undefined' || ngDevMode) && 'Outlet is not activated');
         return this._activatedRoute;
     }
     get activatedRouteData() {
@@ -2468,7 +2478,7 @@ class RouterOutlet {
      */
     detach() {
         if (!this.activated)
-            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$8 && 'Outlet is not activated');
+            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, (typeof ngDevMode === 'undefined' || ngDevMode) && 'Outlet is not activated');
         this.location.detach();
         const cmp = this.activated;
         this.activated = null;
@@ -2496,7 +2506,8 @@ class RouterOutlet {
     }
     activateWith(activatedRoute, environmentInjector) {
         if (this.isActivated) {
-            throw new ɵRuntimeError(4013 /* RuntimeErrorCode.OUTLET_ALREADY_ACTIVATED */, NG_DEV_MODE$8 && 'Cannot activate an already activated outlet');
+            throw new ɵRuntimeError(4013 /* RuntimeErrorCode.OUTLET_ALREADY_ACTIVATED */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                'Cannot activate an already activated outlet');
         }
         this._activatedRoute = activatedRoute;
         const location = this.location;
@@ -2514,10 +2525,10 @@ class RouterOutlet {
         this.changeDetector.markForCheck();
         this.activateEvents.emit(this.activated.instance);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterOutlet, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.5", type: RouterOutlet, isStandalone: true, selector: "router-outlet", inputs: { name: "name" }, outputs: { activateEvents: "activate", deactivateEvents: "deactivate", attachEvents: "attach", detachEvents: "detach" }, exportAs: ["outlet"], usesOnChanges: true, ngImport: i0 }); }
 }
-RouterOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterOutlet, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-RouterOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.4", type: RouterOutlet, isStandalone: true, selector: "router-outlet", inputs: { name: "name" }, outputs: { activateEvents: "activate", deactivateEvents: "deactivate", attachEvents: "attach", detachEvents: "detach" }, exportAs: ["outlet"], usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterOutlet, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterOutlet, decorators: [{
             type: Directive,
             args: [{
                     selector: 'router-outlet',
@@ -2566,10 +2577,10 @@ class OutletInjector {
  * to this `EmptyOutletComponent`.
  */
 class ɵEmptyOutletComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0-next.5", type: ɵEmptyOutletComponent, isStandalone: true, selector: "ng-component", ngImport: i0, template: `<router-outlet></router-outlet>`, isInline: true, dependencies: [{ kind: "directive", type: RouterOutlet, selector: "router-outlet", inputs: ["name"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] }); }
 }
-ɵEmptyOutletComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-ɵEmptyOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0-next.4", type: ɵEmptyOutletComponent, isStandalone: true, selector: "ng-component", ngImport: i0, template: `<router-outlet></router-outlet>`, isInline: true, dependencies: [{ kind: "directive", type: RouterOutlet, selector: "router-outlet", inputs: ["name"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: ɵEmptyOutletComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: ɵEmptyOutletComponent, decorators: [{
             type: Component,
             args: [{
                     template: `<router-outlet></router-outlet>`,
@@ -2854,13 +2865,16 @@ class ActivateRoutes {
         for (const childOutlet of Object.keys(children)) {
             this.deactivateRouteAndItsChildren(children[childOutlet], contexts);
         }
-        if (context && context.outlet) {
-            // Destroy the component
-            context.outlet.deactivate();
-            // Destroy the contexts for all the outlets that were in the component
-            context.children.onOutletDeactivated();
+        if (context) {
+            if (context.outlet) {
+                // Destroy the component
+                context.outlet.deactivate();
+                // Destroy the contexts for all the outlets that were in the component
+                context.children.onOutletDeactivated();
+            }
             // Clear the information about the attached component on the context but keep the reference to
-            // the outlet.
+            // the outlet. Clear even if outlet was not yet activated to avoid activating later with old
+            // info
             context.attachRef = null;
             context.route = null;
         }
@@ -3287,7 +3301,107 @@ function runCanMatchGuards(injector, route, segments, urlSerializer) {
         .pipe(prioritizedGuardValue(), redirectIfUrlTree(urlSerializer));
 }
 
-const noMatch$1 = {
+class NoMatch {
+    constructor(segmentGroup) {
+        this.segmentGroup = segmentGroup || null;
+    }
+}
+class AbsoluteRedirect {
+    constructor(urlTree) {
+        this.urlTree = urlTree;
+    }
+}
+function noMatch$1(segmentGroup) {
+    return throwError(new NoMatch(segmentGroup));
+}
+function absoluteRedirect(newTree) {
+    return throwError(new AbsoluteRedirect(newTree));
+}
+function namedOutletsRedirect(redirectTo) {
+    return throwError(new ɵRuntimeError(4000 /* RuntimeErrorCode.NAMED_OUTLET_REDIRECT */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+        `Only absolute redirects can have named outlets. redirectTo: '${redirectTo}'`));
+}
+function canLoadFails(route) {
+    return throwError(navigationCancelingError((typeof ngDevMode === 'undefined' || ngDevMode) &&
+        `Cannot load children because the guard of the route "path: '${route.path}'" returned false`, 3 /* NavigationCancellationCode.GuardRejected */));
+}
+class ApplyRedirects {
+    constructor(urlSerializer, urlTree) {
+        this.urlSerializer = urlSerializer;
+        this.urlTree = urlTree;
+    }
+    noMatchError(e) {
+        return new ɵRuntimeError(4002 /* RuntimeErrorCode.NO_MATCH */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+            `Cannot match any routes. URL Segment: '${e.segmentGroup}'`);
+    }
+    lineralizeSegments(route, urlTree) {
+        let res = [];
+        let c = urlTree.root;
+        while (true) {
+            res = res.concat(c.segments);
+            if (c.numberOfChildren === 0) {
+                return of(res);
+            }
+            if (c.numberOfChildren > 1 || !c.children[PRIMARY_OUTLET]) {
+                return namedOutletsRedirect(route.redirectTo);
+            }
+            c = c.children[PRIMARY_OUTLET];
+        }
+    }
+    applyRedirectCommands(segments, redirectTo, posParams) {
+        return this.applyRedirectCreateUrlTree(redirectTo, this.urlSerializer.parse(redirectTo), segments, posParams);
+    }
+    applyRedirectCreateUrlTree(redirectTo, urlTree, segments, posParams) {
+        const newRoot = this.createSegmentGroup(redirectTo, urlTree.root, segments, posParams);
+        return new UrlTree(newRoot, this.createQueryParams(urlTree.queryParams, this.urlTree.queryParams), urlTree.fragment);
+    }
+    createQueryParams(redirectToParams, actualParams) {
+        const res = {};
+        Object.entries(redirectToParams).forEach(([k, v]) => {
+            const copySourceValue = typeof v === 'string' && v.startsWith(':');
+            if (copySourceValue) {
+                const sourceName = v.substring(1);
+                res[k] = actualParams[sourceName];
+            }
+            else {
+                res[k] = v;
+            }
+        });
+        return res;
+    }
+    createSegmentGroup(redirectTo, group, segments, posParams) {
+        const updatedSegments = this.createSegments(redirectTo, group.segments, segments, posParams);
+        let children = {};
+        Object.entries(group.children).forEach(([name, child]) => {
+            children[name] = this.createSegmentGroup(redirectTo, child, segments, posParams);
+        });
+        return new UrlSegmentGroup(updatedSegments, children);
+    }
+    createSegments(redirectTo, redirectToSegments, actualSegments, posParams) {
+        return redirectToSegments.map(s => s.path.startsWith(':') ? this.findPosParam(redirectTo, s, posParams) :
+            this.findOrReturn(s, actualSegments));
+    }
+    findPosParam(redirectTo, redirectToUrlSegment, posParams) {
+        const pos = posParams[redirectToUrlSegment.path.substring(1)];
+        if (!pos)
+            throw new ɵRuntimeError(4001 /* RuntimeErrorCode.MISSING_REDIRECT */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                `Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);
+        return pos;
+    }
+    findOrReturn(redirectToUrlSegment, actualSegments) {
+        let idx = 0;
+        for (const s of actualSegments) {
+            if (s.path === redirectToUrlSegment.path) {
+                actualSegments.splice(idx);
+                return s;
+            }
+            idx++;
+        }
+        return redirectToUrlSegment;
+    }
+}
+
+const noMatch = {
     matched: false,
     consumedSegments: [],
     remainingSegments: [],
@@ -3303,12 +3417,12 @@ function matchWithChecks(segmentGroup, route, segments, injector, urlSerializer)
     // navigation
     injector = getOrCreateRouteInjectorIfNeeded(route, injector);
     return runCanMatchGuards(injector, route, segments, urlSerializer)
-        .pipe(map((v) => v === true ? result : { ...noMatch$1 }));
+        .pipe(map((v) => v === true ? result : { ...noMatch }));
 }
 function match(segmentGroup, route, segments) {
     if (route.path === '') {
         if (route.pathMatch === 'full' && (segmentGroup.hasChildren() || segments.length > 0)) {
-            return { ...noMatch$1 };
+            return { ...noMatch };
         }
         return {
             matched: true,
@@ -3321,7 +3435,7 @@ function match(segmentGroup, route, segments) {
     const matcher = route.matcher || defaultUrlMatcher;
     const res = matcher(segments, segmentGroup, route);
     if (!res)
-        return { ...noMatch$1 };
+        return { ...noMatch };
     const posParams = {};
     Object.entries(res.posParams ?? {}).forEach(([k, v]) => {
         posParams[k] = v.path;
@@ -3415,103 +3529,88 @@ function noLeftoversInUrl(segmentGroup, segments, outlet) {
     return segments.length === 0 && !segmentGroup.children[outlet];
 }
 
-const NG_DEV_MODE$7 = typeof ngDevMode === 'undefined' || ngDevMode;
-class NoMatch$1 {
-    constructor(segmentGroup) {
-        this.segmentGroup = segmentGroup || null;
-    }
-}
-class AbsoluteRedirect {
-    constructor(urlTree) {
-        this.urlTree = urlTree;
-    }
-}
-function noMatch(segmentGroup) {
-    return throwError(new NoMatch$1(segmentGroup));
-}
-function absoluteRedirect(newTree) {
-    return throwError(new AbsoluteRedirect(newTree));
-}
-function namedOutletsRedirect(redirectTo) {
-    return throwError(new ɵRuntimeError(4000 /* RuntimeErrorCode.NAMED_OUTLET_REDIRECT */, NG_DEV_MODE$7 &&
-        `Only absolute redirects can have named outlets. redirectTo: '${redirectTo}'`));
-}
-function canLoadFails(route) {
-    return throwError(navigationCancelingError(NG_DEV_MODE$7 &&
-        `Cannot load children because the guard of the route "path: '${route.path}'" returned false`, 3 /* NavigationCancellationCode.GuardRejected */));
-}
-/**
- * Returns the `UrlTree` with the redirection applied.
- *
- * Lazy modules are loaded along the way.
- */
-function applyRedirects$1(injector, configLoader, urlSerializer, urlTree, config) {
-    return new ApplyRedirects(injector, configLoader, urlSerializer, urlTree, config).apply();
+function recognize$1(injector, configLoader, rootComponentType, config, urlTree, urlSerializer, paramsInheritanceStrategy = 'emptyOnly') {
+    return new Recognizer(injector, configLoader, rootComponentType, config, urlTree, paramsInheritanceStrategy, urlSerializer)
+        .recognize();
 }
-class ApplyRedirects {
-    constructor(injector, configLoader, urlSerializer, urlTree, config) {
+class Recognizer {
+    constructor(injector, configLoader, rootComponentType, config, urlTree, paramsInheritanceStrategy, urlSerializer) {
         this.injector = injector;
         this.configLoader = configLoader;
-        this.urlSerializer = urlSerializer;
-        this.urlTree = urlTree;
+        this.rootComponentType = rootComponentType;
         this.config = config;
+        this.urlTree = urlTree;
+        this.paramsInheritanceStrategy = paramsInheritanceStrategy;
+        this.urlSerializer = urlSerializer;
         this.allowRedirects = true;
+        this.applyRedirects = new ApplyRedirects(this.urlSerializer, this.urlTree);
     }
-    apply() {
-        const splitGroup = split(this.urlTree.root, [], [], this.config).segmentGroup;
-        // TODO(atscott): creating a new segment removes the _sourceSegment _segmentIndexShift, which is
-        // only necessary to prevent failures in tests which assert exact object matches. The `split` is
-        // now shared between `applyRedirects` and `recognize` but only the `recognize` step needs these
-        // properties. Before the implementations were merged, the `applyRedirects` would not assign
-        // them. We should be able to remove this logic as a "breaking change" but should do some more
-        // investigation into the failures first.
-        const rootSegmentGroup = new UrlSegmentGroup(splitGroup.segments, splitGroup.children);
-        const expanded$ = this.expandSegmentGroup(this.injector, this.config, rootSegmentGroup, PRIMARY_OUTLET);
-        const urlTrees$ = expanded$.pipe(map((rootSegmentGroup) => {
-            return this.createUrlTree(squashSegmentGroup(rootSegmentGroup), this.urlTree.queryParams, this.urlTree.fragment);
-        }));
-        return urlTrees$.pipe(catchError((e) => {
+    noMatchError(e) {
+        return new ɵRuntimeError(4002 /* RuntimeErrorCode.NO_MATCH */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+            `Cannot match any routes. URL Segment: '${e.segmentGroup}'`);
+    }
+    recognize() {
+        const rootSegmentGroup = split(this.urlTree.root, [], [], this.config).segmentGroup;
+        return this.processSegmentGroup(this.injector, this.config, rootSegmentGroup, PRIMARY_OUTLET)
+            .pipe(catchError((e) => {
             if (e instanceof AbsoluteRedirect) {
                 // After an absolute redirect we do not apply any more redirects!
                 // If this implementation changes, update the documentation note in `redirectTo`.
                 this.allowRedirects = false;
-                // we need to run matching, so we can fetch all lazy-loaded modules
+                this.urlTree = e.urlTree;
                 return this.match(e.urlTree);
             }
-            if (e instanceof NoMatch$1) {
+            if (e instanceof NoMatch) {
                 throw this.noMatchError(e);
             }
             throw e;
+        }), map(children => {
+            // Use Object.freeze to prevent readers of the Router state from modifying it outside
+            // of a navigation, resulting in the router being out of sync with the browser.
+            const root = new ActivatedRouteSnapshot([], Object.freeze({}), Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, {}, PRIMARY_OUTLET, this.rootComponentType, null, {});
+            const rootNode = new TreeNode(root, children);
+            const routeState = new RouterStateSnapshot('', rootNode);
+            const tree = createUrlTreeFromSnapshot(root, [], this.urlTree.queryParams, this.urlTree.fragment);
+            // https://github.com/angular/angular/issues/47307
+            // Creating the tree stringifies the query params
+            // We don't want to do this here so reassign them to the original.
+            tree.queryParams = this.urlTree.queryParams;
+            routeState.url = this.urlSerializer.serialize(tree);
+            this.inheritParamsAndData(routeState._root);
+            return { state: routeState, tree };
         }));
     }
     match(tree) {
-        const expanded$ = this.expandSegmentGroup(this.injector, this.config, tree.root, PRIMARY_OUTLET);
-        const mapped$ = expanded$.pipe(map((rootSegmentGroup) => {
-            return this.createUrlTree(squashSegmentGroup(rootSegmentGroup), tree.queryParams, tree.fragment);
-        }));
-        return mapped$.pipe(catchError((e) => {
-            if (e instanceof NoMatch$1) {
+        const expanded$ = this.processSegmentGroup(this.injector, this.config, tree.root, PRIMARY_OUTLET);
+        return expanded$.pipe(catchError((e) => {
+            if (e instanceof NoMatch) {
                 throw this.noMatchError(e);
             }
             throw e;
         }));
     }
-    noMatchError(e) {
-        return new ɵRuntimeError(4002 /* RuntimeErrorCode.NO_MATCH */, NG_DEV_MODE$7 && `Cannot match any routes. URL Segment: '${e.segmentGroup}'`);
-    }
-    createUrlTree(rootCandidate, queryParams, fragment) {
-        const root = createRoot(rootCandidate);
-        return new UrlTree(root, queryParams, fragment);
+    inheritParamsAndData(routeNode) {
+        const route = routeNode.value;
+        const i = inheritedParamsDataResolve(route, this.paramsInheritanceStrategy);
+        route.params = Object.freeze(i.params);
+        route.data = Object.freeze(i.data);
+        routeNode.children.forEach(n => this.inheritParamsAndData(n));
     }
-    expandSegmentGroup(injector, routes, segmentGroup, outlet) {
+    processSegmentGroup(injector, config, segmentGroup, outlet) {
         if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
-            return this.expandChildren(injector, routes, segmentGroup)
-                .pipe(map((children) => new UrlSegmentGroup([], children)));
+            return this.processChildren(injector, config, segmentGroup);
         }
-        return this.expandSegment(injector, segmentGroup, routes, segmentGroup.segments, outlet, true);
+        return this.processSegment(injector, config, segmentGroup, segmentGroup.segments, outlet, true);
     }
-    // Recursively expand segment groups for all the child outlets
-    expandChildren(injector, routes, segmentGroup) {
+    /**
+     * Matches every child outlet in the `segmentGroup` to a `Route` in the config. Returns `null` if
+     * we cannot find a match for _any_ of the children.
+     *
+     * @param config - The `Routes` to match against
+     * @param segmentGroup - The `UrlSegmentGroup` whose children need to be matched against the
+     *     config.
+     */
+    processChildren(injector, config, segmentGroup) {
         // Expand outlets one at a time, starting with the primary outlet. We need to do it this way
         // because an absolute redirect from the primary outlet takes precedence.
         const childOutlets = [];
@@ -3526,47 +3625,60 @@ class ApplyRedirects {
         return from(childOutlets)
             .pipe(concatMap(childOutlet => {
             const child = segmentGroup.children[childOutlet];
-            // Sort the routes so routes with outlets that match the segment appear
-            // first, followed by routes for other outlets, which might match if they have an
-            // empty path.
-            const sortedRoutes = sortByMatchingOutlets(routes, childOutlet);
-            return this.expandSegmentGroup(injector, sortedRoutes, child, childOutlet)
-                .pipe(map(s => ({ segment: s, outlet: childOutlet })));
-        }), scan((children, expandedChild) => {
-            children[expandedChild.outlet] = expandedChild.segment;
+            // Sort the config so that routes with outlets that match the one being activated
+            // appear first, followed by routes for other outlets, which might match if they have
+            // an empty path.
+            const sortedConfig = sortByMatchingOutlets(config, childOutlet);
+            return this.processSegmentGroup(injector, sortedConfig, child, childOutlet);
+        }), scan((children, outletChildren) => {
+            children.push(...outletChildren);
             return children;
-        }, {}), last$1());
+        }), defaultIfEmpty(null), last$1(), mergeMap(children => {
+            if (children === null)
+                return noMatch$1(segmentGroup);
+            // Because we may have matched two outlets to the same empty path segment, we can have
+            // multiple activated results for the same outlet. We should merge the children of
+            // these results so the final return value is only one `TreeNode` per outlet.
+            const mergedChildren = mergeEmptyPathMatches(children);
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                // This should really never happen - we are only taking the first match for each
+                // outlet and merge the empty path matches.
+                checkOutletNameUniqueness(mergedChildren);
+            }
+            sortActivatedRouteSnapshots(mergedChildren);
+            return of(mergedChildren);
+        }));
     }
-    expandSegment(injector, segmentGroup, routes, segments, outlet, allowRedirects) {
+    processSegment(injector, routes, segmentGroup, segments, outlet, allowRedirects) {
         return from(routes).pipe(concatMap(r => {
-            const expanded$ = this.expandSegmentAgainstRoute(injector, segmentGroup, routes, r, segments, outlet, allowRedirects);
-            return expanded$.pipe(catchError((e) => {
-                if (e instanceof NoMatch$1) {
+            return this
+                .processSegmentAgainstRoute(r._injector ?? injector, routes, r, segmentGroup, segments, outlet, allowRedirects)
+                .pipe(catchError((e) => {
+                if (e instanceof NoMatch) {
                     return of(null);
                 }
                 throw e;
             }));
-        }), first((s) => !!s), catchError((e, _) => {
+        }), first((x) => !!x), catchError(e => {
             if (isEmptyError(e)) {
                 if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
-                    return of(new UrlSegmentGroup([], {}));
+                    return of([]);
                 }
-                return noMatch(segmentGroup);
+                return noMatch$1(segmentGroup);
             }
             throw e;
         }));
     }
-    expandSegmentAgainstRoute(injector, segmentGroup, routes, route, paths, outlet, allowRedirects) {
-        if (!isImmediateMatch(route, segmentGroup, paths, outlet)) {
-            return noMatch(segmentGroup);
-        }
+    processSegmentAgainstRoute(injector, routes, route, rawSegment, segments, outlet, allowRedirects) {
+        if (!isImmediateMatch(route, rawSegment, segments, outlet))
+            return noMatch$1(rawSegment);
         if (route.redirectTo === undefined) {
-            return this.matchSegmentAgainstRoute(injector, segmentGroup, route, paths, outlet);
+            return this.matchSegmentAgainstRoute(injector, rawSegment, route, segments, outlet, allowRedirects);
         }
         if (allowRedirects && this.allowRedirects) {
-            return this.expandSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes, route, paths, outlet);
+            return this.expandSegmentAgainstRouteUsingRedirect(injector, rawSegment, routes, route, segments, outlet);
         }
-        return noMatch(segmentGroup);
+        return noMatch$1(rawSegment);
     }
     expandSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes, route, segments, outlet) {
         if (route.path === '**') {
@@ -3575,66 +3687,93 @@ class ApplyRedirects {
         return this.expandRegularSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes, route, segments, outlet);
     }
     expandWildCardWithParamsAgainstRouteUsingRedirect(injector, routes, route, outlet) {
-        const newTree = this.applyRedirectCommands([], route.redirectTo, {});
+        const newTree = this.applyRedirects.applyRedirectCommands([], route.redirectTo, {});
         if (route.redirectTo.startsWith('/')) {
             return absoluteRedirect(newTree);
         }
-        return this.lineralizeSegments(route, newTree).pipe(mergeMap((newSegments) => {
+        return this.applyRedirects.lineralizeSegments(route, newTree)
+            .pipe(mergeMap((newSegments) => {
             const group = new UrlSegmentGroup(newSegments, {});
-            return this.expandSegment(injector, group, routes, newSegments, outlet, false);
+            return this.processSegment(injector, routes, group, newSegments, outlet, false);
         }));
     }
     expandRegularSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes, route, segments, outlet) {
         const { matched, consumedSegments, remainingSegments, positionalParamSegments } = match(segmentGroup, route, segments);
         if (!matched)
-            return noMatch(segmentGroup);
-        const newTree = this.applyRedirectCommands(consumedSegments, route.redirectTo, positionalParamSegments);
+            return noMatch$1(segmentGroup);
+        const newTree = this.applyRedirects.applyRedirectCommands(consumedSegments, route.redirectTo, positionalParamSegments);
         if (route.redirectTo.startsWith('/')) {
             return absoluteRedirect(newTree);
         }
-        return this.lineralizeSegments(route, newTree).pipe(mergeMap((newSegments) => {
-            return this.expandSegment(injector, segmentGroup, routes, newSegments.concat(remainingSegments), outlet, false);
+        return this.applyRedirects.lineralizeSegments(route, newTree)
+            .pipe(mergeMap((newSegments) => {
+            return this.processSegment(injector, routes, segmentGroup, newSegments.concat(remainingSegments), outlet, false);
         }));
     }
-    matchSegmentAgainstRoute(injector, rawSegmentGroup, route, segments, outlet) {
+    matchSegmentAgainstRoute(injector, rawSegment, route, segments, outlet, allowRedirects) {
+        let matchResult;
         if (route.path === '**') {
-            // Only create the Route's `EnvironmentInjector` if it matches the attempted navigation
-            injector = getOrCreateRouteInjectorIfNeeded(route, injector);
-            if (route.loadChildren) {
-                const loaded$ = route._loadedRoutes ?
-                    of({ routes: route._loadedRoutes, injector: route._loadedInjector }) :
-                    this.configLoader.loadChildren(injector, route);
-                return loaded$.pipe(map((cfg) => {
-                    route._loadedRoutes = cfg.routes;
-                    route._loadedInjector = cfg.injector;
-                    return new UrlSegmentGroup(segments, {});
+            const params = segments.length > 0 ? last(segments).parameters : {};
+            const snapshot = new ActivatedRouteSnapshot(segments, params, Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, getData(route), getOutlet(route), route.component ?? route._loadedComponent ?? null, route, getResolve(route));
+            matchResult = of({
+                snapshot,
+                consumedSegments: [],
+                remainingSegments: [],
+            });
+            // Prior versions of the route matching algorithm would stop matching at the wildcard route.
+            // We should investigate a better strategy for any existing children. Otherwise, these
+            // child segments are silently dropped from the navigation.
+            // https://github.com/angular/angular/issues/40089
+            rawSegment.children = {};
+        }
+        else {
+            matchResult =
+                matchWithChecks(rawSegment, route, segments, injector, this.urlSerializer)
+                    .pipe(map(({ matched, consumedSegments, remainingSegments, parameters }) => {
+                    if (!matched) {
+                        return null;
+                    }
+                    const snapshot = new ActivatedRouteSnapshot(consumedSegments, parameters, Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, getData(route), getOutlet(route), route.component ?? route._loadedComponent ?? null, route, getResolve(route));
+                    return { snapshot, consumedSegments, remainingSegments };
                 }));
-            }
-            return of(new UrlSegmentGroup(segments, {}));
         }
-        return matchWithChecks(rawSegmentGroup, route, segments, injector, this.urlSerializer)
-            .pipe(switchMap(({ matched, consumedSegments, remainingSegments }) => {
-            if (!matched)
-                return noMatch(rawSegmentGroup);
+        return matchResult.pipe(switchMap((result) => {
+            if (result === null) {
+                return noMatch$1(rawSegment);
+            }
             // If the route has an injector created from providers, we should start using that.
             injector = route._injector ?? injector;
-            const childConfig$ = this.getChildConfig(injector, route, segments);
-            return childConfig$.pipe(mergeMap((routerConfig) => {
-                const childInjector = routerConfig.injector ?? injector;
-                const childConfig = routerConfig.routes;
-                const { segmentGroup: splitSegmentGroup, slicedSegments } = split(rawSegmentGroup, consumedSegments, remainingSegments, childConfig);
-                // See comment on the other call to `split` about why this is necessary.
-                const segmentGroup = new UrlSegmentGroup(splitSegmentGroup.segments, splitSegmentGroup.children);
+            return this.getChildConfig(injector, route, segments)
+                .pipe(switchMap(({ routes: childConfig }) => {
+                const childInjector = route._loadedInjector ?? injector;
+                const { snapshot, consumedSegments, remainingSegments } = result;
+                const { segmentGroup, slicedSegments } = split(rawSegment, consumedSegments, remainingSegments, childConfig);
                 if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
-                    const expanded$ = this.expandChildren(childInjector, childConfig, segmentGroup);
-                    return expanded$.pipe(map((children) => new UrlSegmentGroup(consumedSegments, children)));
+                    return this.processChildren(childInjector, childConfig, segmentGroup)
+                        .pipe(map(children => {
+                        if (children === null) {
+                            return null;
+                        }
+                        return [new TreeNode(snapshot, children)];
+                    }));
                 }
                 if (childConfig.length === 0 && slicedSegments.length === 0) {
-                    return of(new UrlSegmentGroup(consumedSegments, {}));
+                    return of([new TreeNode(snapshot, [])]);
                 }
                 const matchedOnOutlet = getOutlet(route) === outlet;
-                const expanded$ = this.expandSegment(childInjector, segmentGroup, childConfig, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet, true);
-                return expanded$.pipe(map((cs) => new UrlSegmentGroup(consumedSegments.concat(cs.segments), cs.children)));
+                // If we matched a config due to empty path match on a different outlet, we need to
+                // continue passing the current outlet for the segment rather than switch to PRIMARY.
+                // Note that we switch to primary when we have a match because outlet configs look like
+                // this: {path: 'a', outlet: 'a', children: [
+                //  {path: 'b', component: B},
+                //  {path: 'c', component: C},
+                // ]}
+                // Notice that the children of the named outlet are configured with the primary outlet
+                return this
+                    .processSegment(childInjector, childConfig, segmentGroup, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet, true)
+                    .pipe(map(children => {
+                    return [new TreeNode(snapshot, children)];
+                }));
             }));
         }));
     }
@@ -3662,256 +3801,6 @@ class ApplyRedirects {
         }
         return of({ routes: [], injector });
     }
-    lineralizeSegments(route, urlTree) {
-        let res = [];
-        let c = urlTree.root;
-        while (true) {
-            res = res.concat(c.segments);
-            if (c.numberOfChildren === 0) {
-                return of(res);
-            }
-            if (c.numberOfChildren > 1 || !c.children[PRIMARY_OUTLET]) {
-                return namedOutletsRedirect(route.redirectTo);
-            }
-            c = c.children[PRIMARY_OUTLET];
-        }
-    }
-    applyRedirectCommands(segments, redirectTo, posParams) {
-        return this.applyRedirectCreateUrlTree(redirectTo, this.urlSerializer.parse(redirectTo), segments, posParams);
-    }
-    applyRedirectCreateUrlTree(redirectTo, urlTree, segments, posParams) {
-        const newRoot = this.createSegmentGroup(redirectTo, urlTree.root, segments, posParams);
-        return new UrlTree(newRoot, this.createQueryParams(urlTree.queryParams, this.urlTree.queryParams), urlTree.fragment);
-    }
-    createQueryParams(redirectToParams, actualParams) {
-        const res = {};
-        Object.entries(redirectToParams).forEach(([k, v]) => {
-            const copySourceValue = typeof v === 'string' && v.startsWith(':');
-            if (copySourceValue) {
-                const sourceName = v.substring(1);
-                res[k] = actualParams[sourceName];
-            }
-            else {
-                res[k] = v;
-            }
-        });
-        return res;
-    }
-    createSegmentGroup(redirectTo, group, segments, posParams) {
-        const updatedSegments = this.createSegments(redirectTo, group.segments, segments, posParams);
-        let children = {};
-        Object.entries(group.children).forEach(([name, child]) => {
-            children[name] = this.createSegmentGroup(redirectTo, child, segments, posParams);
-        });
-        return new UrlSegmentGroup(updatedSegments, children);
-    }
-    createSegments(redirectTo, redirectToSegments, actualSegments, posParams) {
-        return redirectToSegments.map(s => s.path.startsWith(':') ? this.findPosParam(redirectTo, s, posParams) :
-            this.findOrReturn(s, actualSegments));
-    }
-    findPosParam(redirectTo, redirectToUrlSegment, posParams) {
-        const pos = posParams[redirectToUrlSegment.path.substring(1)];
-        if (!pos)
-            throw new ɵRuntimeError(4001 /* RuntimeErrorCode.MISSING_REDIRECT */, NG_DEV_MODE$7 &&
-                `Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);
-        return pos;
-    }
-    findOrReturn(redirectToUrlSegment, actualSegments) {
-        let idx = 0;
-        for (const s of actualSegments) {
-            if (s.path === redirectToUrlSegment.path) {
-                actualSegments.splice(idx);
-                return s;
-            }
-            idx++;
-        }
-        return redirectToUrlSegment;
-    }
-}
-
-function applyRedirects(environmentInjector, configLoader, urlSerializer, config) {
-    return switchMap(t => applyRedirects$1(environmentInjector, configLoader, urlSerializer, t.extractedUrl, config)
-        .pipe(map(urlAfterRedirects => ({ ...t, urlAfterRedirects }))));
-}
-
-const NG_DEV_MODE$6 = typeof ngDevMode === 'undefined' || !!ngDevMode;
-class NoMatch {
-}
-function newObservableError(e) {
-    // TODO(atscott): This pattern is used throughout the router code and can be `throwError` instead.
-    return new Observable((obs) => obs.error(e));
-}
-function recognize$1(injector, rootComponentType, config, urlTree, url, urlSerializer, paramsInheritanceStrategy = 'emptyOnly') {
-    return new Recognizer(injector, rootComponentType, config, urlTree, url, paramsInheritanceStrategy, urlSerializer)
-        .recognize()
-        .pipe(switchMap(result => {
-        if (result === null) {
-            return newObservableError(new NoMatch());
-        }
-        else {
-            return of(result);
-        }
-    }));
-}
-class Recognizer {
-    constructor(injector, rootComponentType, config, urlTree, url, paramsInheritanceStrategy, urlSerializer) {
-        this.injector = injector;
-        this.rootComponentType = rootComponentType;
-        this.config = config;
-        this.urlTree = urlTree;
-        this.url = url;
-        this.paramsInheritanceStrategy = paramsInheritanceStrategy;
-        this.urlSerializer = urlSerializer;
-    }
-    recognize() {
-        const rootSegmentGroup = split(this.urlTree.root, [], [], this.config.filter(c => c.redirectTo === undefined))
-            .segmentGroup;
-        return this.processSegmentGroup(this.injector, this.config, rootSegmentGroup, PRIMARY_OUTLET)
-            .pipe(map(children => {
-            if (children === null) {
-                return null;
-            }
-            // Use Object.freeze to prevent readers of the Router state from modifying it outside of a
-            // navigation, resulting in the router being out of sync with the browser.
-            const root = new ActivatedRouteSnapshot([], Object.freeze({}), Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, {}, PRIMARY_OUTLET, this.rootComponentType, null, {});
-            const rootNode = new TreeNode(root, children);
-            const routeState = new RouterStateSnapshot(this.url, rootNode);
-            this.inheritParamsAndData(routeState._root);
-            return routeState;
-        }));
-    }
-    inheritParamsAndData(routeNode) {
-        const route = routeNode.value;
-        const i = inheritedParamsDataResolve(route, this.paramsInheritanceStrategy);
-        route.params = Object.freeze(i.params);
-        route.data = Object.freeze(i.data);
-        routeNode.children.forEach(n => this.inheritParamsAndData(n));
-    }
-    processSegmentGroup(injector, config, segmentGroup, outlet) {
-        if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
-            return this.processChildren(injector, config, segmentGroup);
-        }
-        return this.processSegment(injector, config, segmentGroup, segmentGroup.segments, outlet);
-    }
-    /**
-     * Matches every child outlet in the `segmentGroup` to a `Route` in the config. Returns `null` if
-     * we cannot find a match for _any_ of the children.
-     *
-     * @param config - The `Routes` to match against
-     * @param segmentGroup - The `UrlSegmentGroup` whose children need to be matched against the
-     *     config.
-     */
-    processChildren(injector, config, segmentGroup) {
-        return from(Object.keys(segmentGroup.children))
-            .pipe(concatMap(childOutlet => {
-            const child = segmentGroup.children[childOutlet];
-            // Sort the config so that routes with outlets that match the one being activated
-            // appear first, followed by routes for other outlets, which might match if they have
-            // an empty path.
-            const sortedConfig = sortByMatchingOutlets(config, childOutlet);
-            return this.processSegmentGroup(injector, sortedConfig, child, childOutlet);
-        }), scan((children, outletChildren) => {
-            if (!children || !outletChildren)
-                return null;
-            children.push(...outletChildren);
-            return children;
-        }), takeWhile(children => children !== null), defaultIfEmpty(null), last$1(), map(children => {
-            if (children === null)
-                return null;
-            // Because we may have matched two outlets to the same empty path segment, we can have
-            // multiple activated results for the same outlet. We should merge the children of
-            // these results so the final return value is only one `TreeNode` per outlet.
-            const mergedChildren = mergeEmptyPathMatches(children);
-            if (NG_DEV_MODE$6) {
-                // This should really never happen - we are only taking the first match for each
-                // outlet and merge the empty path matches.
-                checkOutletNameUniqueness(mergedChildren);
-            }
-            sortActivatedRouteSnapshots(mergedChildren);
-            return mergedChildren;
-        }));
-    }
-    processSegment(injector, routes, segmentGroup, segments, outlet) {
-        return from(routes).pipe(concatMap(r => {
-            return this.processSegmentAgainstRoute(r._injector ?? injector, r, segmentGroup, segments, outlet);
-        }), first((x) => !!x), catchError(e => {
-            if (isEmptyError(e)) {
-                if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
-                    return of([]);
-                }
-                return of(null);
-            }
-            throw e;
-        }));
-    }
-    processSegmentAgainstRoute(injector, route, rawSegment, segments, outlet) {
-        if (route.redirectTo || !isImmediateMatch(route, rawSegment, segments, outlet))
-            return of(null);
-        let matchResult;
-        if (route.path === '**') {
-            const params = segments.length > 0 ? last(segments).parameters : {};
-            const snapshot = new ActivatedRouteSnapshot(segments, params, Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, getData(route), getOutlet(route), route.component ?? route._loadedComponent ?? null, route, getResolve(route));
-            matchResult = of({
-                snapshot,
-                consumedSegments: [],
-                remainingSegments: [],
-            });
-        }
-        else {
-            matchResult =
-                matchWithChecks(rawSegment, route, segments, injector, this.urlSerializer)
-                    .pipe(map(({ matched, consumedSegments, remainingSegments, parameters }) => {
-                    if (!matched) {
-                        return null;
-                    }
-                    const snapshot = new ActivatedRouteSnapshot(consumedSegments, parameters, Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, getData(route), getOutlet(route), route.component ?? route._loadedComponent ?? null, route, getResolve(route));
-                    return { snapshot, consumedSegments, remainingSegments };
-                }));
-        }
-        return matchResult.pipe(switchMap((result) => {
-            if (result === null) {
-                return of(null);
-            }
-            const { snapshot, consumedSegments, remainingSegments } = result;
-            // If the route has an injector created from providers, we should start using that.
-            injector = route._injector ?? injector;
-            const childInjector = route._loadedInjector ?? injector;
-            const childConfig = getChildConfig(route);
-            const { segmentGroup, slicedSegments } = split(rawSegment, consumedSegments, remainingSegments, 
-            // Filter out routes with redirectTo because we are trying to create activated route
-            // snapshots and don't handle redirects here. That should have been done in
-            // `applyRedirects`.
-            childConfig.filter(c => c.redirectTo === undefined));
-            if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
-                return this.processChildren(childInjector, childConfig, segmentGroup).pipe(map(children => {
-                    if (children === null) {
-                        return null;
-                    }
-                    return [new TreeNode(snapshot, children)];
-                }));
-            }
-            if (childConfig.length === 0 && slicedSegments.length === 0) {
-                return of([new TreeNode(snapshot, [])]);
-            }
-            const matchedOnOutlet = getOutlet(route) === outlet;
-            // If we matched a config due to empty path match on a different outlet, we need to
-            // continue passing the current outlet for the segment rather than switch to PRIMARY.
-            // Note that we switch to primary when we have a match because outlet configs look like
-            // this: {path: 'a', outlet: 'a', children: [
-            //  {path: 'b', component: B},
-            //  {path: 'c', component: C},
-            // ]}
-            // Notice that the children of the named outlet are configured with the primary outlet
-            return this
-                .processSegment(childInjector, childConfig, segmentGroup, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet)
-                .pipe(map(children => {
-                if (children === null) {
-                    return null;
-                }
-                return [new TreeNode(snapshot, children)];
-            }));
-        }));
-    }
 }
 function sortActivatedRouteSnapshots(nodes) {
     nodes.sort((a, b) => {
@@ -3922,18 +3811,9 @@ function sortActivatedRouteSnapshots(nodes) {
         return a.value.outlet.localeCompare(b.value.outlet);
     });
 }
-function getChildConfig(route) {
-    if (route.children) {
-        return route.children;
-    }
-    if (route.loadChildren) {
-        return route._loadedRoutes;
-    }
-    return [];
-}
 function hasEmptyPathConfig(node) {
     const config = node.value.routeConfig;
-    return config && config.path === '' && config.redirectTo === undefined;
+    return config && config.path === '';
 }
 /**
  * Finds `TreeNode`s with matching empty path route configs and merges them into `TreeNode` with
@@ -3975,7 +3855,8 @@ function checkOutletNameUniqueness(nodes) {
         if (routeWithSameOutletName) {
             const p = routeWithSameOutletName.url.map(s => s.toString()).join('/');
             const c = n.value.url.map(s => s.toString()).join('/');
-            throw new ɵRuntimeError(4006 /* RuntimeErrorCode.TWO_SEGMENTS_WITH_SAME_OUTLET */, NG_DEV_MODE$6 && `Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
+            throw new ɵRuntimeError(4006 /* RuntimeErrorCode.TWO_SEGMENTS_WITH_SAME_OUTLET */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                `Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
         }
         names[n.value.outlet] = n.value;
     });
@@ -3987,9 +3868,11 @@ function getResolve(route) {
     return route.resolve || {};
 }
 
-function recognize(injector, rootComponentType, config, serializer, paramsInheritanceStrategy) {
-    return mergeMap(t => recognize$1(injector, rootComponentType, config, t.urlAfterRedirects, serializer.serialize(t.urlAfterRedirects), serializer, paramsInheritanceStrategy)
-        .pipe(map(targetSnapshot => ({ ...t, targetSnapshot }))));
+function recognize(injector, configLoader, rootComponentType, config, serializer, paramsInheritanceStrategy) {
+    return mergeMap(t => recognize$1(injector, configLoader, rootComponentType, config, t.extractedUrl, serializer, paramsInheritanceStrategy)
+        .pipe(map(({ state: targetSnapshot, tree: urlAfterRedirects }) => {
+        return { ...t, targetSnapshot, urlAfterRedirects };
+    })));
 }
 
 function resolveData(paramsInheritanceStrategy, injector) {
@@ -4060,7 +3943,6 @@ function switchTap(next) {
     });
 }
 
-const NG_DEV_MODE$5 = typeof ngDevMode === 'undefined' || !!ngDevMode;
 /**
  * The [DI token](guide/glossary/#di-token) for a router configuration.
  *
@@ -4093,7 +3975,8 @@ class RouterConfigLoader {
             if (this.onLoadEndListener) {
                 this.onLoadEndListener(route);
             }
-            NG_DEV_MODE$5 && assertStandalone(route.path ?? '', component);
+            (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                assertStandalone(route.path ?? '', component);
             route._loadedComponent = component;
         }), finalize(() => {
             this.componentLoaders.delete(route);
@@ -4136,7 +4019,8 @@ class RouterConfigLoader {
                 rawRoutes = injector.get(ROUTES, [], InjectFlags.Self | InjectFlags.Optional).flat();
             }
             const routes = rawRoutes.map(standardizeConfig);
-            NG_DEV_MODE$5 && validateConfig(routes, route.path, requireStandaloneComponents);
+            (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                validateConfig(routes, route.path, requireStandaloneComponents);
             return { routes, injector };
         }), finalize(() => {
             this.childrenLoaders.delete(route);
@@ -4158,10 +4042,10 @@ class RouterConfigLoader {
             }
         }));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterConfigLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterConfigLoader, providedIn: 'root' }); }
 }
-RouterConfigLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterConfigLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-RouterConfigLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterConfigLoader, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterConfigLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterConfigLoader, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -4177,7 +4061,6 @@ function maybeUnwrapDefaultExport(input) {
     return isWrappedDefaultExport(input) ? input['default'] : input;
 }
 
-const NG_DEV_MODE$4 = typeof ngDevMode === 'undefined' || !!ngDevMode;
 class NavigationTransitions {
     get hasRequestedNavigation() {
         return this.navigationId !== 0;
@@ -4267,7 +4150,7 @@ class NavigationTransitions {
                     browserUrlTree !== router.currentUrlTree.toString();
                 const onSameUrlNavigation = t.extras.onSameUrlNavigation ?? router.onSameUrlNavigation;
                 if (!urlTransition && onSameUrlNavigation !== 'reload') {
-                    const reason = NG_DEV_MODE$4 ?
+                    const reason = (typeof ngDevMode === 'undefined' || ngDevMode) ?
                         `Navigation to ${t.rawUrl} was ignored because it is the same as the current Router URL.` :
                         '';
                     this.events.next(new NavigationSkipped(t.id, router.serializeUrl(overallTransitionState.rawUrl), reason, 0 /* NavigationSkippedCode.IgnoredSameUrlNavigation */));
@@ -4293,22 +4176,16 @@ class NavigationTransitions {
                         // navigation to always be async
                         return Promise.resolve(t);
                     }), 
-                    // ApplyRedirects
-                    applyRedirects(this.environmentInjector, this.configLoader, this.urlSerializer, router.config), 
-                    // Update the currentNavigation
-                    // `urlAfterRedirects` is guaranteed to be set after this point
+                    // Recognize
+                    recognize(this.environmentInjector, this.configLoader, this.rootComponentType, router.config, this.urlSerializer, router.paramsInheritanceStrategy), 
+                    // Update URL if in `eager` update mode
                     tap(t => {
+                        overallTransitionState.targetSnapshot = t.targetSnapshot;
+                        overallTransitionState.urlAfterRedirects = t.urlAfterRedirects;
                         this.currentNavigation = {
                             ...this.currentNavigation,
                             finalUrl: t.urlAfterRedirects
                         };
-                        overallTransitionState.urlAfterRedirects = t.urlAfterRedirects;
-                    }), 
-                    // Recognize
-                    recognize(this.environmentInjector, this.rootComponentType, router.config, this.urlSerializer, router.paramsInheritanceStrategy), 
-                    // Update URL if in `eager` update mode
-                    tap(t => {
-                        overallTransitionState.targetSnapshot = t.targetSnapshot;
                         if (router.urlUpdateStrategy === 'eager') {
                             if (!t.extras.skipLocationChange) {
                                 const rawUrl = router.urlHandlingStrategy.merge(t.urlAfterRedirects, t.rawUrl);
@@ -4344,7 +4221,7 @@ class NavigationTransitions {
                      * current "settled" URL. This way the next navigation will be coming
                      * from the current URL in the browser.
                      */
-                    const reason = NG_DEV_MODE$4 ?
+                    const reason = (typeof ngDevMode === 'undefined' || ngDevMode) ?
                         `Navigation was ignored because the UrlHandlingStrategy` +
                             ` indicated neither the current URL ${router.rawUrlTree} nor target URL ${t.rawUrl} should be processed.` :
                         '';
@@ -4392,7 +4269,7 @@ class NavigationTransitions {
                             complete: () => {
                                 if (!dataResolved) {
                                     router.restoreHistory(t);
-                                    this.cancelNavigationTransition(t, NG_DEV_MODE$4 ?
+                                    this.cancelNavigationTransition(t, (typeof ngDevMode === 'undefined' || ngDevMode) ?
                                         `At least one route resolver didn't emit any value.` :
                                         '', 2 /* NavigationCancellationCode.NoDataFromResolver */);
                                 }
@@ -4465,7 +4342,7 @@ class NavigationTransitions {
                  * catch-all to make sure the NavigationCancel event is fired when a
                  * navigation gets cancelled but not caught by other means. */
                 if (!completed && !errored) {
-                    const cancelationReason = NG_DEV_MODE$4 ?
+                    const cancelationReason = (typeof ngDevMode === 'undefined' || ngDevMode) ?
                         `Navigation ID ${overallTransitionState
                             .id} is not equal to the current navigation id ${this.navigationId}` :
                         '';
@@ -4539,10 +4416,10 @@ class NavigationTransitions {
         this.events.next(navCancel);
         t.resolve(false);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: NavigationTransitions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: NavigationTransitions, providedIn: 'root' }); }
 }
-NavigationTransitions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: NavigationTransitions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-NavigationTransitions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: NavigationTransitions, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: NavigationTransitions, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: NavigationTransitions, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return []; } });
@@ -4593,10 +4470,10 @@ class TitleStrategy {
     getResolvedTitleForRoute(snapshot) {
         return snapshot.data[RouteTitleKey];
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: TitleStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: TitleStrategy, providedIn: 'root', useFactory: () => inject(DefaultTitleStrategy) }); }
 }
-TitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: TitleStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-TitleStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: TitleStrategy, providedIn: 'root', useFactory: () => inject(DefaultTitleStrategy) });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: TitleStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: TitleStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root', useFactory: () => inject(DefaultTitleStrategy) }]
         }] });
@@ -4619,10 +4496,10 @@ class DefaultTitleStrategy extends TitleStrategy {
             this.title.setTitle(title);
         }
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: DefaultTitleStrategy, deps: [{ token: i1.Title }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: DefaultTitleStrategy, providedIn: 'root' }); }
 }
-DefaultTitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: DefaultTitleStrategy, deps: [{ token: i1.Title }], target: i0.ɵɵFactoryTarget.Injectable });
-DefaultTitleStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: DefaultTitleStrategy, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: DefaultTitleStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: DefaultTitleStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i1.Title }]; } });
@@ -4635,10 +4512,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4",
  * @publicApi
  */
 class RouteReuseStrategy {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouteReuseStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouteReuseStrategy, providedIn: 'root', useFactory: () => inject(DefaultRouteReuseStrategy) }); }
 }
-RouteReuseStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouteReuseStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-RouteReuseStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouteReuseStrategy, providedIn: 'root', useFactory: () => inject(DefaultRouteReuseStrategy) });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouteReuseStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouteReuseStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root', useFactory: () => inject(DefaultRouteReuseStrategy) }]
         }] });
@@ -4689,21 +4566,20 @@ class BaseRouteReuseStrategy {
     }
 }
 class DefaultRouteReuseStrategy extends BaseRouteReuseStrategy {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: DefaultRouteReuseStrategy, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: DefaultRouteReuseStrategy, providedIn: 'root' }); }
 }
-DefaultRouteReuseStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: DefaultRouteReuseStrategy, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-DefaultRouteReuseStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: DefaultRouteReuseStrategy, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: DefaultRouteReuseStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: DefaultRouteReuseStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
-const NG_DEV_MODE$3 = typeof ngDevMode === 'undefined' || !!ngDevMode;
 /**
  * A [DI token](guide/glossary/#di-token) for the router service.
  *
  * @publicApi
  */
-const ROUTER_CONFIGURATION = new InjectionToken(NG_DEV_MODE$3 ? 'router config' : '', {
+const ROUTER_CONFIGURATION = new InjectionToken((typeof ngDevMode === 'undefined' || ngDevMode) ? 'router config' : '', {
     providedIn: 'root',
     factory: () => ({}),
 });
@@ -4716,10 +4592,10 @@ const ROUTER_CONFIGURATION = new InjectionToken(NG_DEV_MODE$3 ? 'router config'
  * @publicApi
  */
 class UrlHandlingStrategy {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: UrlHandlingStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: UrlHandlingStrategy, providedIn: 'root', useFactory: () => inject(DefaultUrlHandlingStrategy) }); }
 }
-UrlHandlingStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: UrlHandlingStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-UrlHandlingStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: UrlHandlingStrategy, providedIn: 'root', useFactory: () => inject(DefaultUrlHandlingStrategy) });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: UrlHandlingStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: UrlHandlingStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root', useFactory: () => inject(DefaultUrlHandlingStrategy) }]
         }] });
@@ -4736,15 +4612,47 @@ class DefaultUrlHandlingStrategy {
     merge(newUrlPart, wholeUrl) {
         return newUrlPart;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: DefaultUrlHandlingStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: DefaultUrlHandlingStrategy, providedIn: 'root' }); }
 }
-DefaultUrlHandlingStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: DefaultUrlHandlingStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-DefaultUrlHandlingStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: DefaultUrlHandlingStrategy, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: DefaultUrlHandlingStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: DefaultUrlHandlingStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
-const NG_DEV_MODE$2 = typeof ngDevMode === 'undefined' || !!ngDevMode;
+var NavigationResult;
+(function (NavigationResult) {
+    NavigationResult[NavigationResult["COMPLETE"] = 0] = "COMPLETE";
+    NavigationResult[NavigationResult["FAILED"] = 1] = "FAILED";
+    NavigationResult[NavigationResult["REDIRECTING"] = 2] = "REDIRECTING";
+})(NavigationResult || (NavigationResult = {}));
+/**
+ * Performs the given action once the router finishes its next/current navigation.
+ *
+ * The navigation is considered complete under the following conditions:
+ * - `NavigationCancel` event emits and the code is not `NavigationCancellationCode.Redirect` or
+ * `NavigationCancellationCode.SupersededByNewNavigation`. In these cases, the
+ * redirecting/superseding navigation must finish.
+ * - `NavigationError`, `NavigationEnd`, or `NavigationSkipped` event emits
+ */
+function afterNextNavigation(router, action) {
+    router.events
+        .pipe(filter((e) => e instanceof NavigationEnd || e instanceof NavigationCancel ||
+        e instanceof NavigationError || e instanceof NavigationSkipped), map(e => {
+        if (e instanceof NavigationEnd || e instanceof NavigationSkipped) {
+            return NavigationResult.COMPLETE;
+        }
+        const redirecting = e instanceof NavigationCancel ?
+            (e.code === 0 /* NavigationCancellationCode.Redirect */ ||
+                e.code === 1 /* NavigationCancellationCode.SupersededByNewNavigation */) :
+            false;
+        return redirecting ? NavigationResult.REDIRECTING : NavigationResult.FAILED;
+    }), filter((result) => result !== NavigationResult.REDIRECTING), take(1))
+        .subscribe(() => {
+        action();
+    });
+}
+
 function defaultErrorHandler(error) {
     throw error;
 }
@@ -4821,6 +4729,7 @@ class Router {
         this.console = inject(ɵConsole);
         this.isNgZoneEnabled = false;
         this.options = inject(ROUTER_CONFIGURATION, { optional: true }) || {};
+        this.pendingTasks = inject(ɵInitialRenderPendingTasks);
         /**
          * A handler for navigation errors in this NgModule.
          *
@@ -5054,7 +4963,7 @@ class Router {
      * ```
      */
     resetConfig(config) {
-        NG_DEV_MODE$2 && validateConfig(config);
+        (typeof ngDevMode === 'undefined' || ngDevMode) && validateConfig(config);
         this.config = config.map(standardizeConfig);
         this.navigated = false;
         this.lastSuccessfulId = -1;
@@ -5189,7 +5098,7 @@ class Router {
     navigateByUrl(url, extras = {
         skipLocationChange: false
     }) {
-        if (NG_DEV_MODE$2) {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
             if (this.isNgZoneEnabled && !NgZone.isInAngularZone()) {
                 this.console.warn(`Navigation triggered outside Angular zone, did you forget to call 'ngZone.run()'?`);
             }
@@ -5318,6 +5227,13 @@ class Router {
             // This is unused when `canceledNavigationResolution` is not computed.
             targetPageId = 0;
         }
+        // Indicate that the navigation is happening.
+        const taskId = this.pendingTasks.add();
+        afterNextNavigation(this, () => {
+            // Remove pending task in a microtask to allow for cancelled
+            // initial navigations and redirects within the same task.
+            Promise.resolve().then(() => this.pendingTasks.remove(taskId));
+        });
         this.navigationTransitions.handleNavigationRequest({
             targetPageId,
             source,
@@ -5416,10 +5332,10 @@ class Router {
         }
         return { navigationId };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: Router, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: Router, providedIn: 'root' }); }
 }
-Router.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: Router, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-Router.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: Router, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: Router, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: Router, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return []; } });
@@ -5427,7 +5343,8 @@ function validateCommands(commands) {
     for (let i = 0; i < commands.length; i++) {
         const cmd = commands[i];
         if (cmd == null) {
-            throw new ɵRuntimeError(4008 /* RuntimeErrorCode.NULLISH_COMMAND */, NG_DEV_MODE$2 && `The requested path contains ${cmd} segment at index ${i}`);
+            throw new ɵRuntimeError(4008 /* RuntimeErrorCode.NULLISH_COMMAND */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                `The requested path contains ${cmd} segment at index ${i}`);
         }
     }
 }
@@ -5704,10 +5621,10 @@ class RouterLink {
             preserveFragment: this.preserveFragment,
         });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterLink, deps: [{ token: Router }, { token: ActivatedRoute }, { token: 'tabindex', attribute: true }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i3.LocationStrategy }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.5", type: RouterLink, isStandalone: true, selector: "[routerLink]", inputs: { target: "target", queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", state: "state", relativeTo: "relativeTo", preserveFragment: "preserveFragment", skipLocationChange: "skipLocationChange", replaceUrl: "replaceUrl", routerLink: "routerLink" }, host: { listeners: { "click": "onClick($event.button,$event.ctrlKey,$event.shiftKey,$event.altKey,$event.metaKey)" }, properties: { "attr.target": "this.target" } }, usesOnChanges: true, ngImport: i0 }); }
 }
-RouterLink.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterLink, deps: [{ token: Router }, { token: ActivatedRoute }, { token: 'tabindex', attribute: true }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i3.LocationStrategy }], target: i0.ɵɵFactoryTarget.Directive });
-RouterLink.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.4", type: RouterLink, isStandalone: true, selector: "[routerLink]", inputs: { target: "target", queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", state: "state", relativeTo: "relativeTo", preserveFragment: "preserveFragment", skipLocationChange: "skipLocationChange", replaceUrl: "replaceUrl", routerLink: "routerLink" }, host: { listeners: { "click": "onClick($event.button,$event.ctrlKey,$event.shiftKey,$event.altKey,$event.metaKey)" }, properties: { "attr.target": "this.target" } }, usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterLink, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterLink, decorators: [{
             type: Directive,
             args: [{
                     selector: '[routerLink]',
@@ -5927,10 +5844,10 @@ class RouterLinkActive {
         const isActiveCheckFn = this.isLinkActive(this.router);
         return this.link && isActiveCheckFn(this.link) || this.links.some(isActiveCheckFn);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterLinkActive, deps: [{ token: Router }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: RouterLink, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.5", type: RouterLinkActive, isStandalone: true, selector: "[routerLinkActive]", inputs: { routerLinkActiveOptions: "routerLinkActiveOptions", ariaCurrentWhenActive: "ariaCurrentWhenActive", routerLinkActive: "routerLinkActive" }, outputs: { isActiveChange: "isActiveChange" }, queries: [{ propertyName: "links", predicate: RouterLink, descendants: true }], exportAs: ["routerLinkActive"], usesOnChanges: true, ngImport: i0 }); }
 }
-RouterLinkActive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterLinkActive, deps: [{ token: Router }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: RouterLink, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
-RouterLinkActive.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.4", type: RouterLinkActive, isStandalone: true, selector: "[routerLinkActive]", inputs: { routerLinkActiveOptions: "routerLinkActiveOptions", ariaCurrentWhenActive: "ariaCurrentWhenActive", routerLinkActive: "routerLinkActive" }, outputs: { isActiveChange: "isActiveChange" }, queries: [{ propertyName: "links", predicate: RouterLink, descendants: true }], exportAs: ["routerLinkActive"], usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterLinkActive, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterLinkActive, decorators: [{
             type: Directive,
             args: [{
                     selector: '[routerLinkActive]',
@@ -5982,10 +5899,10 @@ class PreloadAllModules {
     preload(route, fn) {
         return fn().pipe(catchError(() => of(null)));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: PreloadAllModules, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: PreloadAllModules, providedIn: 'root' }); }
 }
-PreloadAllModules.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: PreloadAllModules, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-PreloadAllModules.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: PreloadAllModules, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: PreloadAllModules, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: PreloadAllModules, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -6002,10 +5919,10 @@ class NoPreloading {
     preload(route, fn) {
         return of(null);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: NoPreloading, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: NoPreloading, providedIn: 'root' }); }
 }
-NoPreloading.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: NoPreloading, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-NoPreloading.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: NoPreloading, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: NoPreloading, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: NoPreloading, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -6064,7 +5981,7 @@ class RouterPreloader {
                 (route.loadComponent && !route._loadedComponent)) {
                 res.push(this.preloadConfig(injectorForCurrentRoute, route));
             }
-            else if (route.children || route._loadedRoutes) {
+            if (route.children || route._loadedRoutes) {
                 res.push(this.processRoutes(injectorForChildren, (route.children ?? route._loadedRoutes)));
             }
         }
@@ -6098,10 +6015,10 @@ class RouterPreloader {
             }
         });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterPreloader, deps: [{ token: Router }, { token: i0.Compiler }, { token: i0.EnvironmentInjector }, { token: PreloadingStrategy }, { token: RouterConfigLoader }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterPreloader, providedIn: 'root' }); }
 }
-RouterPreloader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterPreloader, deps: [{ token: Router }, { token: i0.Compiler }, { token: i0.EnvironmentInjector }, { token: PreloadingStrategy }, { token: RouterConfigLoader }], target: i0.ɵɵFactoryTarget.Injectable });
-RouterPreloader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterPreloader, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterPreloader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterPreloader, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: Router }, { type: i0.Compiler }, { type: i0.EnvironmentInjector }, { type: PreloadingStrategy }, { type: RouterConfigLoader }]; } });
@@ -6194,47 +6111,13 @@ class RouterScroller {
         this.routerEventsSubscription?.unsubscribe();
         this.scrollEventsSubscription?.unsubscribe();
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterScroller }); }
 }
-RouterScroller.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
-RouterScroller.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterScroller });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterScroller, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterScroller, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: UrlSerializer }, { type: NavigationTransitions }, { type: i3.ViewportScroller }, { type: i0.NgZone }, { type: undefined }]; } });
 
-var NavigationResult;
-(function (NavigationResult) {
-    NavigationResult[NavigationResult["COMPLETE"] = 0] = "COMPLETE";
-    NavigationResult[NavigationResult["FAILED"] = 1] = "FAILED";
-    NavigationResult[NavigationResult["REDIRECTING"] = 2] = "REDIRECTING";
-})(NavigationResult || (NavigationResult = {}));
-/**
- * Performs the given action once the router finishes its next/current navigation.
- *
- * The navigation is considered complete under the following conditions:
- * - `NavigationCancel` event emits and the code is not `NavigationCancellationCode.Redirect` or
- * `NavigationCancellationCode.SupersededByNewNavigation`. In these cases, the
- * redirecting/superseding navigation must finish.
- * - `NavigationError`, `NavigationEnd`, or `NavigationSkipped` event emits
- */
-function afterNextNavigation(router, action) {
-    router.events
-        .pipe(filter((e) => e instanceof NavigationEnd || e instanceof NavigationCancel ||
-        e instanceof NavigationError || e instanceof NavigationSkipped), map(e => {
-        if (e instanceof NavigationEnd || e instanceof NavigationSkipped) {
-            return NavigationResult.COMPLETE;
-        }
-        const redirecting = e instanceof NavigationCancel ?
-            (e.code === 0 /* NavigationCancellationCode.Redirect */ ||
-                e.code === 1 /* NavigationCancellationCode.SupersededByNewNavigation */) :
-            false;
-        return redirecting ? NavigationResult.REDIRECTING : NavigationResult.FAILED;
-    }), filter((result) => result !== NavigationResult.REDIRECTING), take(1))
-        .subscribe(() => {
-        action();
-    });
-}
-
-const NG_DEV_MODE$1 = typeof ngDevMode === 'undefined' || ngDevMode;
 /**
  * Sets up providers necessary to enable `Router` functionality for the application.
  * Allows to configure a set of routes as well as extra features that should be enabled.
@@ -6274,7 +6157,9 @@ const NG_DEV_MODE$1 = typeof ngDevMode === 'undefined' || ngDevMode;
 function provideRouter(routes, ...features) {
     return makeEnvironmentProviders([
         { provide: ROUTES, multi: true, useValue: routes },
-        NG_DEV_MODE$1 ? { provide: ROUTER_IS_PROVIDED, useValue: true } : [],
+        (typeof ngDevMode === 'undefined' || ngDevMode) ?
+            { provide: ROUTER_IS_PROVIDED, useValue: true } :
+            [],
         { provide: ActivatedRoute, useFactory: rootRoute, deps: [Router] },
         { provide: APP_BOOTSTRAP_LISTENER, multi: true, useFactory: getBootstrapListener },
         features.map(feature => feature.ɵproviders),
@@ -6326,7 +6211,7 @@ const routerIsProvidedDevModeCheck = {
 function provideRoutes(routes) {
     return [
         { provide: ROUTES, multi: true, useValue: routes },
-        NG_DEV_MODE$1 ? routerIsProvidedDevModeCheck : [],
+        (typeof ngDevMode === 'undefined' || ngDevMode) ? routerIsProvidedDevModeCheck : [],
     ];
 }
 /**
@@ -6393,12 +6278,12 @@ function getBootstrapListener() {
  * `enabledBlocking`, the first navigation waits until bootstrapping is finished before continuing
  * to the activation phase.
  */
-const BOOTSTRAP_DONE = new InjectionToken(NG_DEV_MODE$1 ? 'bootstrap done indicator' : '', {
+const BOOTSTRAP_DONE = new InjectionToken((typeof ngDevMode === 'undefined' || ngDevMode) ? 'bootstrap done indicator' : '', {
     factory: () => {
         return new Subject();
     }
 });
-const INITIAL_NAVIGATION = new InjectionToken(NG_DEV_MODE$1 ? 'initial navigation' : '', { providedIn: 'root', factory: () => 1 /* InitialNavigation.EnabledNonBlocking */ });
+const INITIAL_NAVIGATION = new InjectionToken((typeof ngDevMode === 'undefined' || ngDevMode) ? 'initial navigation' : '', { providedIn: 'root', factory: () => 1 /* InitialNavigation.EnabledNonBlocking */ });
 /**
  * Configures initial navigation to start before the root component is created.
  *
@@ -6527,7 +6412,7 @@ function withDisabledInitialNavigation() {
  */
 function withDebugTracing() {
     let providers = [];
-    if (NG_DEV_MODE$1) {
+    if (typeof ngDevMode === 'undefined' || ngDevMode) {
         providers = [{
                 provide: ENVIRONMENT_INITIALIZER,
                 multi: true,
@@ -6549,7 +6434,7 @@ function withDebugTracing() {
     }
     return routerFeature(1 /* RouterFeatureKind.DebugTracingFeature */, providers);
 }
-const ROUTER_PRELOADER = new InjectionToken(NG_DEV_MODE$1 ? 'router preloader' : '');
+const ROUTER_PRELOADER = new InjectionToken((typeof ngDevMode === 'undefined' || ngDevMode) ? 'router preloader' : '');
 /**
  * Allows to configure a preloading strategy to use. The strategy is configured by providing a
  * reference to a class that implements a `PreloadingStrategy`.
@@ -6691,7 +6576,6 @@ function withNavigationErrorHandler(fn) {
     return routerFeature(7 /* RouterFeatureKind.NavigationErrorHandlerFeature */, providers);
 }
 
-const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
 /**
  * The directives defined in the `RouterModule`.
  */
@@ -6699,7 +6583,8 @@ const ROUTER_DIRECTIVES = [RouterOutlet, RouterLink, RouterLinkActive, ɵEmptyOu
 /**
  * @docsNotRequired
  */
-const ROUTER_FORROOT_GUARD = new InjectionToken(NG_DEV_MODE ? 'router duplicate forRoot guard' : 'ROUTER_FORROOT_GUARD');
+const ROUTER_FORROOT_GUARD = new InjectionToken((typeof ngDevMode === 'undefined' || ngDevMode) ? 'router duplicate forRoot guard' :
+    'ROUTER_FORROOT_GUARD');
 // TODO(atscott): All of these except `ActivatedRoute` are `providedIn: 'root'`. They are only kept
 // here to avoid a breaking change whereby the provider order matters based on where the
 // `RouterModule`/`RouterTestingModule` is imported. These can/should be removed as a "breaking"
@@ -6713,7 +6598,8 @@ const ROUTER_PROVIDERS = [
     RouterConfigLoader,
     // Only used to warn when `provideRoutes` is used without `RouterModule` or `provideRouter`. Can
     // be removed when `provideRoutes` is removed.
-    NG_DEV_MODE ? { provide: ROUTER_IS_PROVIDED, useValue: true } : [],
+    (typeof ngDevMode === 'undefined' || ngDevMode) ? { provide: ROUTER_IS_PROVIDED, useValue: true } :
+        [],
 ];
 function routerNgProbeToken() {
     return new NgProbeToken('Router', Router);
@@ -6764,7 +6650,9 @@ class RouterModule {
             ngModule: RouterModule,
             providers: [
                 ROUTER_PROVIDERS,
-                NG_DEV_MODE ? (config?.enableTracing ? withDebugTracing().ɵproviders : []) : [],
+                (typeof ngDevMode === 'undefined' || ngDevMode) ?
+                    (config?.enableTracing ? withDebugTracing().ɵproviders : []) :
+                    [],
                 { provide: ROUTES, multi: true, useValue: routes },
                 {
                     provide: ROUTER_FORROOT_GUARD,
@@ -6803,11 +6691,11 @@ class RouterModule {
             providers: [{ provide: ROUTES, multi: true, useValue: routes }],
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterModule, deps: [{ token: ROUTER_FORROOT_GUARD, optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterModule, imports: [RouterOutlet, RouterLink, RouterLinkActive, ɵEmptyOutletComponent], exports: [RouterOutlet, RouterLink, RouterLinkActive, ɵEmptyOutletComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterModule, imports: [ɵEmptyOutletComponent] }); }
 }
-RouterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterModule, deps: [{ token: ROUTER_FORROOT_GUARD, optional: true }], target: i0.ɵɵFactoryTarget.NgModule });
-RouterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterModule, imports: [RouterOutlet, RouterLink, RouterLinkActive, ɵEmptyOutletComponent], exports: [RouterOutlet, RouterLink, RouterLinkActive, ɵEmptyOutletComponent] });
-RouterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterModule, imports: [ɵEmptyOutletComponent] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.4", ngImport: i0, type: RouterModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.5", ngImport: i0, type: RouterModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: ROUTER_DIRECTIVES,
@@ -6850,7 +6738,7 @@ function providePathLocationStrategy() {
     return { provide: LocationStrategy, useClass: PathLocationStrategy };
 }
 function provideForRootGuard(router) {
-    if (NG_DEV_MODE && router) {
+    if ((typeof ngDevMode === 'undefined' || ngDevMode) && router) {
         throw new ɵRuntimeError(4007 /* RuntimeErrorCode.FOR_ROOT_CALLED_TWICE */, `The Router was provided more than once. This can happen if 'forRoot' is used outside of the root injector.` +
             ` Lazy loaded modules should use RouterModule.forChild() instead.`);
     }
@@ -6873,7 +6761,7 @@ function provideInitialNavigation(config) {
  *
  * @publicApi
  */
-const ROUTER_INITIALIZER = new InjectionToken(NG_DEV_MODE ? 'Router Initializer' : '');
+const ROUTER_INITIALIZER = new InjectionToken((typeof ngDevMode === 'undefined' || ngDevMode) ? 'Router Initializer' : '');
 function provideRouterInitializer() {
     return [
         // ROUTER_INITIALIZER token should be removed. It's public API but shouldn't be. We can just
@@ -6952,7 +6840,7 @@ function mapToResolve(provider) {
 /**
  * @publicApi
  */
-const VERSION = new Version('16.0.0-next.4');
+const VERSION = new Version('16.0.0-next.5');
 
 /**
  * @module