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

package/{fesm2020 → fesm2022}/router.mjs

@@ -1,15 +1,15 @@
 /**
- * @license Angular v16.0.0-next.4
+ * @license Angular v16.0.0-next.6
  * (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, InjectionToken, reflectComponentType, Component, createEnvironmentInjector, ɵisNgModule, isStandalone, ɵisInjectable, 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, combineLatest, EmptyError, 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.6", ngImport: i0, type: UrlSerializer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", 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;
     }
@@ -1688,6 +1700,79 @@ function stringifyEvent(routerEvent) {
     }
 }
 
+/**
+ * Store contextual information about a `RouterOutlet`
+ *
+ * @publicApi
+ */
+class OutletContext {
+    constructor() {
+        this.outlet = null;
+        this.route = null;
+        this.injector = null;
+        this.children = new ChildrenOutletContexts();
+        this.attachRef = null;
+    }
+}
+/**
+ * Store contextual information about the children (= nested) `RouterOutlet`
+ *
+ * @publicApi
+ */
+class ChildrenOutletContexts {
+    constructor() {
+        // contexts for child outlets, by name.
+        this.contexts = new Map();
+    }
+    /** Called when a `RouterOutlet` directive is instantiated */
+    onChildOutletCreated(childName, outlet) {
+        const context = this.getOrCreateContext(childName);
+        context.outlet = outlet;
+        this.contexts.set(childName, context);
+    }
+    /**
+     * Called when a `RouterOutlet` directive is destroyed.
+     * We need to keep the context as the outlet could be destroyed inside a NgIf and might be
+     * re-created later.
+     */
+    onChildOutletDestroyed(childName) {
+        const context = this.getContext(childName);
+        if (context) {
+            context.outlet = null;
+            context.attachRef = null;
+        }
+    }
+    /**
+     * Called when the corresponding route is deactivated during navigation.
+     * Because the component get destroyed, all children outlet are destroyed.
+     */
+    onOutletDeactivated() {
+        const contexts = this.contexts;
+        this.contexts = new Map();
+        return contexts;
+    }
+    onOutletReAttached(contexts) {
+        this.contexts = contexts;
+    }
+    getOrCreateContext(childName) {
+        let context = this.getContext(childName);
+        if (!context) {
+            context = new OutletContext();
+            this.contexts.set(childName, context);
+        }
+        return context;
+    }
+    getContext(childName) {
+        return this.contexts.get(childName) || null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: ChildrenOutletContexts, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: ChildrenOutletContexts, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: ChildrenOutletContexts, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class Tree {
     constructor(root) {
         this._root = root;
@@ -1881,9 +1966,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() {
@@ -2171,146 +2255,6 @@ function equalParamsAndUrlSegments(a, b) {
         (!a.parent || equalParamsAndUrlSegments(a.parent, b.parent));
 }
 
-function createRouterState(routeReuseStrategy, curr, prevState) {
-    const root = createNode(routeReuseStrategy, curr._root, prevState ? prevState._root : undefined);
-    return new RouterState(root, curr);
-}
-function createNode(routeReuseStrategy, curr, prevState) {
-    // reuse an activated route that is currently displayed on the screen
-    if (prevState && routeReuseStrategy.shouldReuseRoute(curr.value, prevState.value.snapshot)) {
-        const value = prevState.value;
-        value._futureSnapshot = curr.value;
-        const children = createOrReuseChildren(routeReuseStrategy, curr, prevState);
-        return new TreeNode(value, children);
-    }
-    else {
-        if (routeReuseStrategy.shouldAttach(curr.value)) {
-            // retrieve an activated route that is used to be displayed, but is not currently displayed
-            const detachedRouteHandle = routeReuseStrategy.retrieve(curr.value);
-            if (detachedRouteHandle !== null) {
-                const tree = detachedRouteHandle.route;
-                tree.value._futureSnapshot = curr.value;
-                tree.children = curr.children.map(c => createNode(routeReuseStrategy, c));
-                return tree;
-            }
-        }
-        const value = createActivatedRoute(curr.value);
-        const children = curr.children.map(c => createNode(routeReuseStrategy, c));
-        return new TreeNode(value, children);
-    }
-}
-function createOrReuseChildren(routeReuseStrategy, curr, prevState) {
-    return curr.children.map(child => {
-        for (const p of prevState.children) {
-            if (routeReuseStrategy.shouldReuseRoute(child.value, p.value.snapshot)) {
-                return createNode(routeReuseStrategy, child, p);
-            }
-        }
-        return createNode(routeReuseStrategy, child);
-    });
-}
-function createActivatedRoute(c) {
-    return new ActivatedRoute(new BehaviorSubject(c.url), new BehaviorSubject(c.params), new BehaviorSubject(c.queryParams), new BehaviorSubject(c.fragment), new BehaviorSubject(c.data), c.outlet, c.component, c);
-}
-
-const NAVIGATION_CANCELING_ERROR = 'ngNavigationCancelingError';
-function redirectingNavigationError(urlSerializer, redirect) {
-    const { redirectTo, navigationBehaviorOptions } = isUrlTree(redirect) ? { redirectTo: redirect, navigationBehaviorOptions: undefined } : redirect;
-    const error = navigationCancelingError(ngDevMode && `Redirecting to "${urlSerializer.serialize(redirectTo)}"`, 0 /* NavigationCancellationCode.Redirect */, redirect);
-    error.url = redirectTo;
-    error.navigationBehaviorOptions = navigationBehaviorOptions;
-    return error;
-}
-function navigationCancelingError(message, code, redirectUrl) {
-    const error = new Error('NavigationCancelingError: ' + (message || ''));
-    error[NAVIGATION_CANCELING_ERROR] = true;
-    error.cancellationCode = code;
-    if (redirectUrl) {
-        error.url = redirectUrl;
-    }
-    return error;
-}
-function isRedirectingNavigationCancelingError$1(error) {
-    return isNavigationCancelingError$1(error) && isUrlTree(error.url);
-}
-function isNavigationCancelingError$1(error) {
-    return error && error[NAVIGATION_CANCELING_ERROR];
-}
-
-/**
- * Store contextual information about a `RouterOutlet`
- *
- * @publicApi
- */
-class OutletContext {
-    constructor() {
-        this.outlet = null;
-        this.route = null;
-        this.injector = null;
-        this.children = new ChildrenOutletContexts();
-        this.attachRef = null;
-    }
-}
-/**
- * Store contextual information about the children (= nested) `RouterOutlet`
- *
- * @publicApi
- */
-class ChildrenOutletContexts {
-    constructor() {
-        // contexts for child outlets, by name.
-        this.contexts = new Map();
-    }
-    /** Called when a `RouterOutlet` directive is instantiated */
-    onChildOutletCreated(childName, outlet) {
-        const context = this.getOrCreateContext(childName);
-        context.outlet = outlet;
-        this.contexts.set(childName, context);
-    }
-    /**
-     * Called when a `RouterOutlet` directive is destroyed.
-     * We need to keep the context as the outlet could be destroyed inside a NgIf and might be
-     * re-created later.
-     */
-    onChildOutletDestroyed(childName) {
-        const context = this.getContext(childName);
-        if (context) {
-            context.outlet = null;
-            context.attachRef = null;
-        }
-    }
-    /**
-     * Called when the corresponding route is deactivated during navigation.
-     * Because the component get destroyed, all children outlet are destroyed.
-     */
-    onOutletDeactivated() {
-        const contexts = this.contexts;
-        this.contexts = new Map();
-        return contexts;
-    }
-    onOutletReAttached(contexts) {
-        this.contexts = contexts;
-    }
-    getOrCreateContext(childName) {
-        let context = this.getContext(childName);
-        if (!context) {
-            context = new OutletContext();
-            this.contexts.set(childName, context);
-        }
-        return context;
-    }
-    getContext(childName) {
-        return this.contexts.get(childName) || null;
-    }
-}
-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: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-const NG_DEV_MODE$8 = typeof ngDevMode === 'undefined' || ngDevMode;
 /**
  * @description
  *
@@ -2388,6 +2332,13 @@ class RouterOutlet {
         this.location = inject(ViewContainerRef);
         this.changeDetector = inject(ChangeDetectorRef);
         this.environmentInjector = inject(EnvironmentInjector);
+        this.inputBinder = inject(INPUT_BINDER, { optional: true });
+        /** @nodoc */
+        this.supportsBindingToComponentInputs = true;
+    }
+    /** @internal */
+    get activatedComponentRef() {
+        return this.activated;
     }
     /** @nodoc */
     ngOnChanges(changes) {
@@ -2413,6 +2364,7 @@ class RouterOutlet {
         if (this.isTrackedInParentContexts(this.name)) {
             this.parentContexts.onChildOutletDestroyed(this.name);
         }
+        this.inputBinder?.unsubscribeFromRouteData(this);
     }
     isTrackedInParentContexts(outletName) {
         return this.parentContexts.getContext(outletName)?.outlet === this;
@@ -2449,12 +2401,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 +2420,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;
@@ -2483,6 +2435,7 @@ class RouterOutlet {
         this.activated = ref;
         this._activatedRoute = activatedRoute;
         this.location.insert(ref.hostView);
+        this.inputBinder?.bindActivatedRouteToOutletComponent(this);
         this.attachEvents.emit(ref.instance);
     }
     deactivate() {
@@ -2496,7 +2449,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;
@@ -2512,12 +2466,13 @@ class RouterOutlet {
         // Calling `markForCheck` to make sure we will run the change detection when the
         // `RouterOutlet` is inside a `ChangeDetectionStrategy.OnPush` component.
         this.changeDetector.markForCheck();
+        this.inputBinder?.bindActivatedRouteToOutletComponent(this);
         this.activateEvents.emit(this.activated.instance);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: RouterOutlet, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.6", 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.6", ngImport: i0, type: RouterOutlet, decorators: [{
             type: Directive,
             args: [{
                     selector: 'router-outlet',
@@ -2555,48 +2510,178 @@ class OutletInjector {
         return this.parent.get(token, notFoundValue);
     }
 }
-
+const INPUT_BINDER = new InjectionToken('');
 /**
- * This component is used internally within the router to be a placeholder when an empty
- * router-outlet is needed. For example, with a config such as:
- *
- * `{path: 'parent', outlet: 'nav', children: [...]}`
- *
- * In order to render, there needs to be a component on this config, which will default
- * to this `EmptyOutletComponent`.
+ * Injectable used as a tree-shakable provider for opting in to binding router data to component
+ * inputs.
+ *
+ * The RouterOutlet registers itself with this service when an `ActivatedRoute` is attached or
+ * activated. When this happens, the service subscribes to the `ActivatedRoute` observables (params,
+ * queryParams, data) and sets the inputs of the component using `ComponentRef.setInput`.
+ * Importantly, when an input does not have an item in the route data with a matching key, this
+ * input is set to `undefined`. If it were not done this way, the previous information would be
+ * retained if the data got removed from the route (i.e. if a query parameter is removed).
+ *
+ * The `RouterOutlet` should unregister itself when destroyed via `unsubscribeFromRouteData` so that
+ * the subscriptions are cleaned up.
  */
-class ɵEmptyOutletComponent {
+class RoutedComponentInputBinder {
+    constructor() {
+        this.outletDataSubscriptions = new Map;
+    }
+    bindActivatedRouteToOutletComponent(outlet) {
+        this.unsubscribeFromRouteData(outlet);
+        this.subscribeToRouteData(outlet);
+    }
+    unsubscribeFromRouteData(outlet) {
+        this.outletDataSubscriptions.get(outlet)?.unsubscribe();
+        this.outletDataSubscriptions.delete(outlet);
+    }
+    subscribeToRouteData(outlet) {
+        const { activatedRoute } = outlet;
+        const dataSubscription = combineLatest([
+            activatedRoute.queryParams,
+            activatedRoute.params,
+            activatedRoute.data,
+        ])
+            .pipe(switchMap(([queryParams, params, data]) => {
+            // Promise.resolve is used to avoid synchronously writing the wrong data when two of
+            // the Observables in the `combineLatest` stream emit one after another.
+            return Promise.resolve({ ...queryParams, ...params, ...data });
+        }))
+            .subscribe(data => {
+            // Outlet may have been deactivated or changed names to be associated with a different
+            // route
+            if (!outlet.isActivated || !outlet.activatedComponentRef ||
+                outlet.activatedRoute !== activatedRoute || activatedRoute.component === null) {
+                this.unsubscribeFromRouteData(outlet);
+                return;
+            }
+            const mirror = reflectComponentType(activatedRoute.component);
+            if (!mirror) {
+                this.unsubscribeFromRouteData(outlet);
+                return;
+            }
+            for (const { templateName } of mirror.inputs) {
+                outlet.activatedComponentRef.setInput(templateName, data[templateName]);
+            }
+        });
+        this.outletDataSubscriptions.set(outlet, dataSubscription);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: RoutedComponentInputBinder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: RoutedComponentInputBinder }); }
 }
-ɵ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: [{
-            type: Component,
-            args: [{
-                    template: `<router-outlet></router-outlet>`,
-                    imports: [RouterOutlet],
-                    standalone: true,
-                }]
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: RoutedComponentInputBinder, decorators: [{
+            type: Injectable
         }] });
 
-/**
- * Creates an `EnvironmentInjector` if the `Route` has providers and one does not already exist
- * and returns the injector. Otherwise, if the `Route` does not have `providers`, returns the
- * `currentInjector`.
- *
- * @param route The route that might have providers
- * @param currentInjector The parent injector of the `Route`
- */
-function getOrCreateRouteInjectorIfNeeded(route, currentInjector) {
-    if (route.providers && !route._injector) {
-        route._injector =
-            createEnvironmentInjector(route.providers, currentInjector, `Route: ${route.path}`);
-    }
-    return route._injector ?? currentInjector;
-}
-function getLoadedRoutes(route) {
-    return route._loadedRoutes;
+function createRouterState(routeReuseStrategy, curr, prevState) {
+    const root = createNode(routeReuseStrategy, curr._root, prevState ? prevState._root : undefined);
+    return new RouterState(root, curr);
 }
-function getLoadedInjector(route) {
+function createNode(routeReuseStrategy, curr, prevState) {
+    // reuse an activated route that is currently displayed on the screen
+    if (prevState && routeReuseStrategy.shouldReuseRoute(curr.value, prevState.value.snapshot)) {
+        const value = prevState.value;
+        value._futureSnapshot = curr.value;
+        const children = createOrReuseChildren(routeReuseStrategy, curr, prevState);
+        return new TreeNode(value, children);
+    }
+    else {
+        if (routeReuseStrategy.shouldAttach(curr.value)) {
+            // retrieve an activated route that is used to be displayed, but is not currently displayed
+            const detachedRouteHandle = routeReuseStrategy.retrieve(curr.value);
+            if (detachedRouteHandle !== null) {
+                const tree = detachedRouteHandle.route;
+                tree.value._futureSnapshot = curr.value;
+                tree.children = curr.children.map(c => createNode(routeReuseStrategy, c));
+                return tree;
+            }
+        }
+        const value = createActivatedRoute(curr.value);
+        const children = curr.children.map(c => createNode(routeReuseStrategy, c));
+        return new TreeNode(value, children);
+    }
+}
+function createOrReuseChildren(routeReuseStrategy, curr, prevState) {
+    return curr.children.map(child => {
+        for (const p of prevState.children) {
+            if (routeReuseStrategy.shouldReuseRoute(child.value, p.value.snapshot)) {
+                return createNode(routeReuseStrategy, child, p);
+            }
+        }
+        return createNode(routeReuseStrategy, child);
+    });
+}
+function createActivatedRoute(c) {
+    return new ActivatedRoute(new BehaviorSubject(c.url), new BehaviorSubject(c.params), new BehaviorSubject(c.queryParams), new BehaviorSubject(c.fragment), new BehaviorSubject(c.data), c.outlet, c.component, c);
+}
+
+const NAVIGATION_CANCELING_ERROR = 'ngNavigationCancelingError';
+function redirectingNavigationError(urlSerializer, redirect) {
+    const { redirectTo, navigationBehaviorOptions } = isUrlTree(redirect) ? { redirectTo: redirect, navigationBehaviorOptions: undefined } : redirect;
+    const error = navigationCancelingError(ngDevMode && `Redirecting to "${urlSerializer.serialize(redirectTo)}"`, 0 /* NavigationCancellationCode.Redirect */, redirect);
+    error.url = redirectTo;
+    error.navigationBehaviorOptions = navigationBehaviorOptions;
+    return error;
+}
+function navigationCancelingError(message, code, redirectUrl) {
+    const error = new Error('NavigationCancelingError: ' + (message || ''));
+    error[NAVIGATION_CANCELING_ERROR] = true;
+    error.cancellationCode = code;
+    if (redirectUrl) {
+        error.url = redirectUrl;
+    }
+    return error;
+}
+function isRedirectingNavigationCancelingError$1(error) {
+    return isNavigationCancelingError$1(error) && isUrlTree(error.url);
+}
+function isNavigationCancelingError$1(error) {
+    return error && error[NAVIGATION_CANCELING_ERROR];
+}
+
+/**
+ * This component is used internally within the router to be a placeholder when an empty
+ * router-outlet is needed. For example, with a config such as:
+ *
+ * `{path: 'parent', outlet: 'nav', children: [...]}`
+ *
+ * In order to render, there needs to be a component on this config, which will default
+ * to this `EmptyOutletComponent`.
+ */
+class ɵEmptyOutletComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0-next.6", 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.6", ngImport: i0, type: ɵEmptyOutletComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `<router-outlet></router-outlet>`,
+                    imports: [RouterOutlet],
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * Creates an `EnvironmentInjector` if the `Route` has providers and one does not already exist
+ * and returns the injector. Otherwise, if the `Route` does not have `providers`, returns the
+ * `currentInjector`.
+ *
+ * @param route The route that might have providers
+ * @param currentInjector The parent injector of the `Route`
+ */
+function getOrCreateRouteInjectorIfNeeded(route, currentInjector) {
+    if (route.providers && !route._injector) {
+        route._injector =
+            createEnvironmentInjector(route.providers, currentInjector, `Route: ${route.path}`);
+    }
+    return route._injector ?? currentInjector;
+}
+function getLoadedRoutes(route) {
+    return route._loadedRoutes;
+}
+function getLoadedInjector(route) {
     return route._loadedInjector;
 }
 function getLoadedComponent(route) {
@@ -2765,17 +2850,19 @@ function getClosestRouteInjector(snapshot) {
     return null;
 }
 
-const activateRoutes = (rootContexts, routeReuseStrategy, forwardEvent) => map(t => {
-    new ActivateRoutes(routeReuseStrategy, t.targetRouterState, t.currentRouterState, forwardEvent)
+let warnedAboutUnsupportedInputBinding = false;
+const activateRoutes = (rootContexts, routeReuseStrategy, forwardEvent, inputBindingEnabled) => map(t => {
+    new ActivateRoutes(routeReuseStrategy, t.targetRouterState, t.currentRouterState, forwardEvent, inputBindingEnabled)
         .activate(rootContexts);
     return t;
 });
 class ActivateRoutes {
-    constructor(routeReuseStrategy, futureState, currState, forwardEvent) {
+    constructor(routeReuseStrategy, futureState, currState, forwardEvent, inputBindingEnabled) {
         this.routeReuseStrategy = routeReuseStrategy;
         this.futureState = futureState;
         this.currState = currState;
         this.forwardEvent = forwardEvent;
+        this.inputBindingEnabled = inputBindingEnabled;
     }
     activate(parentContexts) {
         const futureRoot = this.futureState._root;
@@ -2854,13 +2941,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;
         }
@@ -2927,6 +3017,16 @@ class ActivateRoutes {
                 this.activateChildRoutes(futureNode, null, parentContexts);
             }
         }
+        if ((typeof ngDevMode === 'undefined' || ngDevMode)) {
+            const context = parentContexts.getOrCreateContext(future.outlet);
+            const outlet = context.outlet;
+            if (outlet && this.inputBindingEnabled && !outlet.supportsBindingToComponentInputs &&
+                !warnedAboutUnsupportedInputBinding) {
+                console.warn(`'withComponentInputBinding' feature is enabled but ` +
+                    `this application is using an outlet that may not support binding to component inputs.`);
+                warnedAboutUnsupportedInputBinding = true;
+            }
+        }
     }
 }
 
@@ -3287,136 +3387,7 @@ function runCanMatchGuards(injector, route, segments, urlSerializer) {
         .pipe(prioritizedGuardValue(), redirectIfUrlTree(urlSerializer));
 }
 
-const noMatch$1 = {
-    matched: false,
-    consumedSegments: [],
-    remainingSegments: [],
-    parameters: {},
-    positionalParamSegments: {}
-};
-function matchWithChecks(segmentGroup, route, segments, injector, urlSerializer) {
-    const result = match(segmentGroup, route, segments);
-    if (!result.matched) {
-        return of(result);
-    }
-    // Only create the Route's `EnvironmentInjector` if it matches the attempted
-    // navigation
-    injector = getOrCreateRouteInjectorIfNeeded(route, injector);
-    return runCanMatchGuards(injector, route, segments, urlSerializer)
-        .pipe(map((v) => v === true ? result : { ...noMatch$1 }));
-}
-function match(segmentGroup, route, segments) {
-    if (route.path === '') {
-        if (route.pathMatch === 'full' && (segmentGroup.hasChildren() || segments.length > 0)) {
-            return { ...noMatch$1 };
-        }
-        return {
-            matched: true,
-            consumedSegments: [],
-            remainingSegments: segments,
-            parameters: {},
-            positionalParamSegments: {}
-        };
-    }
-    const matcher = route.matcher || defaultUrlMatcher;
-    const res = matcher(segments, segmentGroup, route);
-    if (!res)
-        return { ...noMatch$1 };
-    const posParams = {};
-    Object.entries(res.posParams ?? {}).forEach(([k, v]) => {
-        posParams[k] = v.path;
-    });
-    const parameters = res.consumed.length > 0 ?
-        { ...posParams, ...res.consumed[res.consumed.length - 1].parameters } :
-        posParams;
-    return {
-        matched: true,
-        consumedSegments: res.consumed,
-        remainingSegments: segments.slice(res.consumed.length),
-        // TODO(atscott): investigate combining parameters and positionalParamSegments
-        parameters,
-        positionalParamSegments: res.posParams ?? {}
-    };
-}
-function split(segmentGroup, consumedSegments, slicedSegments, config) {
-    if (slicedSegments.length > 0 &&
-        containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, config)) {
-        const s = new UrlSegmentGroup(consumedSegments, createChildrenForEmptyPaths(config, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));
-        return { segmentGroup: s, slicedSegments: [] };
-    }
-    if (slicedSegments.length === 0 &&
-        containsEmptyPathMatches(segmentGroup, slicedSegments, config)) {
-        const s = new UrlSegmentGroup(segmentGroup.segments, addEmptyPathsToChildrenIfNeeded(segmentGroup, consumedSegments, slicedSegments, config, segmentGroup.children));
-        return { segmentGroup: s, slicedSegments };
-    }
-    const s = new UrlSegmentGroup(segmentGroup.segments, segmentGroup.children);
-    return { segmentGroup: s, slicedSegments };
-}
-function addEmptyPathsToChildrenIfNeeded(segmentGroup, consumedSegments, slicedSegments, routes, children) {
-    const res = {};
-    for (const r of routes) {
-        if (emptyPathMatch(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {
-            const s = new UrlSegmentGroup([], {});
-            res[getOutlet(r)] = s;
-        }
-    }
-    return { ...children, ...res };
-}
-function createChildrenForEmptyPaths(routes, primarySegment) {
-    const res = {};
-    res[PRIMARY_OUTLET] = primarySegment;
-    for (const r of routes) {
-        if (r.path === '' && getOutlet(r) !== PRIMARY_OUTLET) {
-            const s = new UrlSegmentGroup([], {});
-            res[getOutlet(r)] = s;
-        }
-    }
-    return res;
-}
-function containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, routes) {
-    return routes.some(r => emptyPathMatch(segmentGroup, slicedSegments, r) && getOutlet(r) !== PRIMARY_OUTLET);
-}
-function containsEmptyPathMatches(segmentGroup, slicedSegments, routes) {
-    return routes.some(r => emptyPathMatch(segmentGroup, slicedSegments, r));
-}
-function emptyPathMatch(segmentGroup, slicedSegments, r) {
-    if ((segmentGroup.hasChildren() || slicedSegments.length > 0) && r.pathMatch === 'full') {
-        return false;
-    }
-    return r.path === '';
-}
-/**
- * Determines if `route` is a path match for the `rawSegment`, `segments`, and `outlet` without
- * verifying that its children are a full match for the remainder of the `rawSegment` children as
- * well.
- */
-function isImmediateMatch(route, rawSegment, segments, outlet) {
-    // We allow matches to empty paths when the outlets differ so we can match a url like `/(b:b)` to
-    // a config like
-    // * `{path: '', children: [{path: 'b', outlet: 'b'}]}`
-    // or even
-    // * `{path: '', outlet: 'a', children: [{path: 'b', outlet: 'b'}]`
-    //
-    // The exception here is when the segment outlet is for the primary outlet. This would
-    // result in a match inside the named outlet because all children there are written as primary
-    // outlets. So we need to prevent child named outlet matches in a url like `/b` in a config like
-    // * `{path: '', outlet: 'x' children: [{path: 'b'}]}`
-    // This should only match if the url is `/(x:b)`.
-    if (getOutlet(route) !== outlet &&
-        (outlet === PRIMARY_OUTLET || !emptyPathMatch(rawSegment, segments, route))) {
-        return false;
-    }
-    if (route.path === '**') {
-        return true;
-    }
-    return match(rawSegment, route, segments).matched;
-}
-function noLeftoversInUrl(segmentGroup, segments, outlet) {
-    return segments.length === 0 && !segmentGroup.children[outlet];
-}
-
-const NG_DEV_MODE$7 = typeof ngDevMode === 'undefined' || ngDevMode;
-class NoMatch$1 {
+class NoMatch {
     constructor(segmentGroup) {
         this.segmentGroup = segmentGroup || null;
     }
@@ -3426,241 +3397,28 @@ class AbsoluteRedirect {
         this.urlTree = urlTree;
     }
 }
-function noMatch(segmentGroup) {
-    return throwError(new NoMatch$1(segmentGroup));
+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 */, NG_DEV_MODE$7 &&
+    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(NG_DEV_MODE$7 &&
+    return throwError(navigationCancelingError((typeof ngDevMode === 'undefined' || ngDevMode) &&
         `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();
-}
 class ApplyRedirects {
-    constructor(injector, configLoader, urlSerializer, urlTree, config) {
-        this.injector = injector;
-        this.configLoader = configLoader;
+    constructor(urlSerializer, urlTree) {
         this.urlSerializer = urlSerializer;
         this.urlTree = urlTree;
-        this.config = config;
-        this.allowRedirects = true;
-    }
-    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) => {
-            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
-                return this.match(e.urlTree);
-            }
-            if (e instanceof NoMatch$1) {
-                throw this.noMatchError(e);
-            }
-            throw e;
-        }));
-    }
-    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) {
-                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);
-    }
-    expandSegmentGroup(injector, routes, segmentGroup, outlet) {
-        if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
-            return this.expandChildren(injector, routes, segmentGroup)
-                .pipe(map((children) => new UrlSegmentGroup([], children)));
-        }
-        return this.expandSegment(injector, segmentGroup, routes, segmentGroup.segments, outlet, true);
-    }
-    // Recursively expand segment groups for all the child outlets
-    expandChildren(injector, routes, 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 = [];
-        for (const child of Object.keys(segmentGroup.children)) {
-            if (child === 'primary') {
-                childOutlets.unshift(child);
-            }
-            else {
-                childOutlets.push(child);
-            }
-        }
-        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;
-            return children;
-        }, {}), last$1());
-    }
-    expandSegment(injector, segmentGroup, routes, 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 of(null);
-                }
-                throw e;
-            }));
-        }), first((s) => !!s), catchError((e, _) => {
-            if (isEmptyError(e)) {
-                if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
-                    return of(new UrlSegmentGroup([], {}));
-                }
-                return noMatch(segmentGroup);
-            }
-            throw e;
-        }));
-    }
-    expandSegmentAgainstRoute(injector, segmentGroup, routes, route, paths, outlet, allowRedirects) {
-        if (!isImmediateMatch(route, segmentGroup, paths, outlet)) {
-            return noMatch(segmentGroup);
-        }
-        if (route.redirectTo === undefined) {
-            return this.matchSegmentAgainstRoute(injector, segmentGroup, route, paths, outlet);
-        }
-        if (allowRedirects && this.allowRedirects) {
-            return this.expandSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes, route, paths, outlet);
-        }
-        return noMatch(segmentGroup);
-    }
-    expandSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes, route, segments, outlet) {
-        if (route.path === '**') {
-            return this.expandWildCardWithParamsAgainstRouteUsingRedirect(injector, routes, route, outlet);
-        }
-        return this.expandRegularSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes, route, segments, outlet);
-    }
-    expandWildCardWithParamsAgainstRouteUsingRedirect(injector, routes, route, outlet) {
-        const newTree = this.applyRedirectCommands([], route.redirectTo, {});
-        if (route.redirectTo.startsWith('/')) {
-            return absoluteRedirect(newTree);
-        }
-        return this.lineralizeSegments(route, newTree).pipe(mergeMap((newSegments) => {
-            const group = new UrlSegmentGroup(newSegments, {});
-            return this.expandSegment(injector, group, routes, 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);
-        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);
-        }));
-    }
-    matchSegmentAgainstRoute(injector, rawSegmentGroup, route, segments, outlet) {
-        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, {});
-                }));
-            }
-            return of(new UrlSegmentGroup(segments, {}));
-        }
-        return matchWithChecks(rawSegmentGroup, route, segments, injector, this.urlSerializer)
-            .pipe(switchMap(({ matched, consumedSegments, remainingSegments }) => {
-            if (!matched)
-                return noMatch(rawSegmentGroup);
-            // 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);
-                if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
-                    const expanded$ = this.expandChildren(childInjector, childConfig, segmentGroup);
-                    return expanded$.pipe(map((children) => new UrlSegmentGroup(consumedSegments, children)));
-                }
-                if (childConfig.length === 0 && slicedSegments.length === 0) {
-                    return of(new UrlSegmentGroup(consumedSegments, {}));
-                }
-                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)));
-            }));
-        }));
-    }
-    getChildConfig(injector, route, segments) {
-        if (route.children) {
-            // The children belong to the same module
-            return of({ routes: route.children, injector });
-        }
-        if (route.loadChildren) {
-            // lazy children belong to the loaded module
-            if (route._loadedRoutes !== undefined) {
-                return of({ routes: route._loadedRoutes, injector: route._loadedInjector });
-            }
-            return runCanLoadGuards(injector, route, segments, this.urlSerializer)
-                .pipe(mergeMap((shouldLoadResult) => {
-                if (shouldLoadResult) {
-                    return this.configLoader.loadChildren(injector, route)
-                        .pipe(tap((cfg) => {
-                        route._loadedRoutes = cfg.routes;
-                        route._loadedInjector = cfg.injector;
-                    }));
-                }
-                return canLoadFails(route);
-            }));
-        }
-        return of({ routes: [], injector });
+        return new ɵRuntimeError(4002 /* RuntimeErrorCode.NO_MATCH */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+            `Cannot match any routes. URL Segment: '${e.segmentGroup}'`);
     }
     lineralizeSegments(route, urlTree) {
         let res = [];
@@ -3712,7 +3470,7 @@ class ApplyRedirects {
     findPosParam(redirectTo, redirectToUrlSegment, posParams) {
         const pos = posParams[redirectToUrlSegment.path.substring(1)];
         if (!pos)
-            throw new ɵRuntimeError(4001 /* RuntimeErrorCode.MISSING_REDIRECT */, NG_DEV_MODE$7 &&
+            throw new ɵRuntimeError(4001 /* RuntimeErrorCode.MISSING_REDIRECT */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
                 `Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);
         return pos;
     }
@@ -3725,59 +3483,196 @@ class ApplyRedirects {
             }
             idx++;
         }
-        return redirectToUrlSegment;
+        return redirectToUrlSegment;
+    }
+}
+
+const noMatch = {
+    matched: false,
+    consumedSegments: [],
+    remainingSegments: [],
+    parameters: {},
+    positionalParamSegments: {}
+};
+function matchWithChecks(segmentGroup, route, segments, injector, urlSerializer) {
+    const result = match(segmentGroup, route, segments);
+    if (!result.matched) {
+        return of(result);
+    }
+    // Only create the Route's `EnvironmentInjector` if it matches the attempted
+    // navigation
+    injector = getOrCreateRouteInjectorIfNeeded(route, injector);
+    return runCanMatchGuards(injector, route, segments, urlSerializer)
+        .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 };
+        }
+        return {
+            matched: true,
+            consumedSegments: [],
+            remainingSegments: segments,
+            parameters: {},
+            positionalParamSegments: {}
+        };
+    }
+    const matcher = route.matcher || defaultUrlMatcher;
+    const res = matcher(segments, segmentGroup, route);
+    if (!res)
+        return { ...noMatch };
+    const posParams = {};
+    Object.entries(res.posParams ?? {}).forEach(([k, v]) => {
+        posParams[k] = v.path;
+    });
+    const parameters = res.consumed.length > 0 ?
+        { ...posParams, ...res.consumed[res.consumed.length - 1].parameters } :
+        posParams;
+    return {
+        matched: true,
+        consumedSegments: res.consumed,
+        remainingSegments: segments.slice(res.consumed.length),
+        // TODO(atscott): investigate combining parameters and positionalParamSegments
+        parameters,
+        positionalParamSegments: res.posParams ?? {}
+    };
+}
+function split(segmentGroup, consumedSegments, slicedSegments, config) {
+    if (slicedSegments.length > 0 &&
+        containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, config)) {
+        const s = new UrlSegmentGroup(consumedSegments, createChildrenForEmptyPaths(config, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));
+        return { segmentGroup: s, slicedSegments: [] };
+    }
+    if (slicedSegments.length === 0 &&
+        containsEmptyPathMatches(segmentGroup, slicedSegments, config)) {
+        const s = new UrlSegmentGroup(segmentGroup.segments, addEmptyPathsToChildrenIfNeeded(segmentGroup, consumedSegments, slicedSegments, config, segmentGroup.children));
+        return { segmentGroup: s, slicedSegments };
+    }
+    const s = new UrlSegmentGroup(segmentGroup.segments, segmentGroup.children);
+    return { segmentGroup: s, slicedSegments };
+}
+function addEmptyPathsToChildrenIfNeeded(segmentGroup, consumedSegments, slicedSegments, routes, children) {
+    const res = {};
+    for (const r of routes) {
+        if (emptyPathMatch(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {
+            const s = new UrlSegmentGroup([], {});
+            res[getOutlet(r)] = s;
+        }
+    }
+    return { ...children, ...res };
+}
+function createChildrenForEmptyPaths(routes, primarySegment) {
+    const res = {};
+    res[PRIMARY_OUTLET] = primarySegment;
+    for (const r of routes) {
+        if (r.path === '' && getOutlet(r) !== PRIMARY_OUTLET) {
+            const s = new UrlSegmentGroup([], {});
+            res[getOutlet(r)] = s;
+        }
     }
+    return res;
 }
-
-function applyRedirects(environmentInjector, configLoader, urlSerializer, config) {
-    return switchMap(t => applyRedirects$1(environmentInjector, configLoader, urlSerializer, t.extractedUrl, config)
-        .pipe(map(urlAfterRedirects => ({ ...t, urlAfterRedirects }))));
+function containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, routes) {
+    return routes.some(r => emptyPathMatch(segmentGroup, slicedSegments, r) && getOutlet(r) !== PRIMARY_OUTLET);
 }
-
-const NG_DEV_MODE$6 = typeof ngDevMode === 'undefined' || !!ngDevMode;
-class NoMatch {
+function containsEmptyPathMatches(segmentGroup, slicedSegments, routes) {
+    return routes.some(r => emptyPathMatch(segmentGroup, slicedSegments, r));
 }
-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 emptyPathMatch(segmentGroup, slicedSegments, r) {
+    if ((segmentGroup.hasChildren() || slicedSegments.length > 0) && r.pathMatch === 'full') {
+        return false;
+    }
+    return r.path === '';
 }
-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);
-        }
-    }));
+/**
+ * Determines if `route` is a path match for the `rawSegment`, `segments`, and `outlet` without
+ * verifying that its children are a full match for the remainder of the `rawSegment` children as
+ * well.
+ */
+function isImmediateMatch(route, rawSegment, segments, outlet) {
+    // We allow matches to empty paths when the outlets differ so we can match a url like `/(b:b)` to
+    // a config like
+    // * `{path: '', children: [{path: 'b', outlet: 'b'}]}`
+    // or even
+    // * `{path: '', outlet: 'a', children: [{path: 'b', outlet: 'b'}]`
+    //
+    // The exception here is when the segment outlet is for the primary outlet. This would
+    // result in a match inside the named outlet because all children there are written as primary
+    // outlets. So we need to prevent child named outlet matches in a url like `/b` in a config like
+    // * `{path: '', outlet: 'x' children: [{path: 'b'}]}`
+    // This should only match if the url is `/(x:b)`.
+    if (getOutlet(route) !== outlet &&
+        (outlet === PRIMARY_OUTLET || !emptyPathMatch(rawSegment, segments, route))) {
+        return false;
+    }
+    if (route.path === '**') {
+        return true;
+    }
+    return match(rawSegment, route, segments).matched;
+}
+function noLeftoversInUrl(segmentGroup, segments, outlet) {
+    return segments.length === 0 && !segmentGroup.children[outlet];
+}
+
+function recognize$1(injector, configLoader, rootComponentType, config, urlTree, urlSerializer, paramsInheritanceStrategy = 'emptyOnly') {
+    return new Recognizer(injector, configLoader, rootComponentType, config, urlTree, paramsInheritanceStrategy, urlSerializer)
+        .recognize();
 }
 class Recognizer {
-    constructor(injector, rootComponentType, config, urlTree, url, paramsInheritanceStrategy, urlSerializer) {
+    constructor(injector, configLoader, rootComponentType, config, urlTree, paramsInheritanceStrategy, urlSerializer) {
         this.injector = injector;
+        this.configLoader = configLoader;
         this.rootComponentType = rootComponentType;
         this.config = config;
         this.urlTree = urlTree;
-        this.url = url;
         this.paramsInheritanceStrategy = paramsInheritanceStrategy;
         this.urlSerializer = urlSerializer;
+        this.allowRedirects = true;
+        this.applyRedirects = new ApplyRedirects(this.urlSerializer, this.urlTree);
+    }
+    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.filter(c => c.redirectTo === undefined))
-            .segmentGroup;
+        const rootSegmentGroup = split(this.urlTree.root, [], [], this.config).segmentGroup;
         return this.processSegmentGroup(this.injector, this.config, rootSegmentGroup, PRIMARY_OUTLET)
-            .pipe(map(children => {
-            if (children === null) {
-                return null;
+            .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;
+                this.urlTree = e.urlTree;
+                return this.match(e.urlTree);
+            }
+            if (e instanceof NoMatch) {
+                throw this.noMatchError(e);
             }
-            // 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.
+            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(this.url, rootNode);
+            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 routeState;
+            return { state: routeState, tree };
+        }));
+    }
+    match(tree) {
+        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;
         }));
     }
     inheritParamsAndData(routeNode) {
@@ -3791,7 +3686,7 @@ class Recognizer {
         if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
             return this.processChildren(injector, config, segmentGroup);
         }
-        return this.processSegment(injector, config, segmentGroup, segmentGroup.segments, outlet);
+        return this.processSegment(injector, config, segmentGroup, segmentGroup.segments, outlet, true);
     }
     /**
      * Matches every child outlet in the `segmentGroup` to a `Route` in the config. Returns `null` if
@@ -3802,7 +3697,18 @@ class Recognizer {
      *     config.
      */
     processChildren(injector, config, segmentGroup) {
-        return from(Object.keys(segmentGroup.children))
+        // 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 = [];
+        for (const child of Object.keys(segmentGroup.children)) {
+            if (child === 'primary') {
+                childOutlets.unshift(child);
+            }
+            else {
+                childOutlets.push(child);
+            }
+        }
+        return from(childOutlets)
             .pipe(concatMap(childOutlet => {
             const child = segmentGroup.children[childOutlet];
             // Sort the config so that routes with outlets that match the one being activated
@@ -3811,42 +3717,86 @@ class Recognizer {
             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 => {
+        }), defaultIfEmpty(null), last$1(), mergeMap(children => {
             if (children === null)
-                return 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 (NG_DEV_MODE$6) {
+            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 mergedChildren;
+            return of(mergedChildren);
         }));
     }
-    processSegment(injector, routes, segmentGroup, segments, outlet) {
+    processSegment(injector, routes, segmentGroup, segments, outlet, allowRedirects) {
         return from(routes).pipe(concatMap(r => {
-            return this.processSegmentAgainstRoute(r._injector ?? injector, r, segmentGroup, segments, outlet);
+            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((x) => !!x), catchError(e => {
             if (isEmptyError(e)) {
                 if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
                     return of([]);
                 }
-                return of(null);
+                return noMatch$1(segmentGroup);
             }
             throw e;
         }));
     }
-    processSegmentAgainstRoute(injector, route, rawSegment, segments, outlet) {
-        if (route.redirectTo || !isImmediateMatch(route, rawSegment, segments, outlet))
-            return of(null);
+    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, rawSegment, route, segments, outlet, allowRedirects);
+        }
+        if (allowRedirects && this.allowRedirects) {
+            return this.expandSegmentAgainstRouteUsingRedirect(injector, rawSegment, routes, route, segments, outlet);
+        }
+        return noMatch$1(rawSegment);
+    }
+    expandSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes, route, segments, outlet) {
+        if (route.path === '**') {
+            return this.expandWildCardWithParamsAgainstRouteUsingRedirect(injector, routes, route, outlet);
+        }
+        return this.expandRegularSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes, route, segments, outlet);
+    }
+    expandWildCardWithParamsAgainstRouteUsingRedirect(injector, routes, route, outlet) {
+        const newTree = this.applyRedirects.applyRedirectCommands([], route.redirectTo, {});
+        if (route.redirectTo.startsWith('/')) {
+            return absoluteRedirect(newTree);
+        }
+        return this.applyRedirects.lineralizeSegments(route, newTree)
+            .pipe(mergeMap((newSegments) => {
+            const group = new UrlSegmentGroup(newSegments, {});
+            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$1(segmentGroup);
+        const newTree = this.applyRedirects.applyRedirectCommands(consumedSegments, route.redirectTo, positionalParamSegments);
+        if (route.redirectTo.startsWith('/')) {
+            return absoluteRedirect(newTree);
+        }
+        return this.applyRedirects.lineralizeSegments(route, newTree)
+            .pipe(mergeMap((newSegments) => {
+            return this.processSegment(injector, routes, segmentGroup, newSegments.concat(remainingSegments), outlet, false);
+        }));
+    }
+    matchSegmentAgainstRoute(injector, rawSegment, route, segments, outlet, allowRedirects) {
         let matchResult;
         if (route.path === '**') {
             const params = segments.length > 0 ? last(segments).parameters : {};
@@ -3856,6 +3806,11 @@ class Recognizer {
                 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 =
@@ -3870,47 +3825,67 @@ class Recognizer {
         }
         return matchResult.pipe(switchMap((result) => {
             if (result === null) {
-                return of(null);
+                return noMatch$1(rawSegment);
             }
-            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 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()) {
+                    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, true)
+                    .pipe(map(children => {
                     return [new TreeNode(snapshot, children)];
                 }));
+            }));
+        }));
+    }
+    getChildConfig(injector, route, segments) {
+        if (route.children) {
+            // The children belong to the same module
+            return of({ routes: route.children, injector });
+        }
+        if (route.loadChildren) {
+            // lazy children belong to the loaded module
+            if (route._loadedRoutes !== undefined) {
+                return of({ routes: route._loadedRoutes, injector: route._loadedInjector });
             }
-            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 runCanLoadGuards(injector, route, segments, this.urlSerializer)
+                .pipe(mergeMap((shouldLoadResult) => {
+                if (shouldLoadResult) {
+                    return this.configLoader.loadChildren(injector, route)
+                        .pipe(tap((cfg) => {
+                        route._loadedRoutes = cfg.routes;
+                        route._loadedInjector = cfg.injector;
+                    }));
                 }
-                return [new TreeNode(snapshot, children)];
+                return canLoadFails(route);
             }));
-        }));
+        }
+        return of({ routes: [], injector });
     }
 }
 function sortActivatedRouteSnapshots(nodes) {
@@ -3922,18 +3897,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 +3941,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 +3954,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 +4029,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 +4061,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 +4105,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 +4128,10 @@ class RouterConfigLoader {
             }
         }));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: RouterConfigLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", ngImport: i0, type: RouterConfigLoader, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -4177,7 +4147,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;
@@ -4190,6 +4159,7 @@ class NavigationTransitions {
         this.environmentInjector = inject(EnvironmentInjector);
         this.urlSerializer = inject(UrlSerializer);
         this.rootContexts = inject(ChildrenOutletContexts);
+        this.inputBindingEnabled = inject(INPUT_BINDER, { optional: true }) !== null;
         this.navigationId = 0;
         /**
          * Hook that enables you to pause navigation after the preactivation phase.
@@ -4267,7 +4237,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 +4263,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 +4308,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 +4356,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 */);
                                 }
@@ -4445,7 +4409,11 @@ class NavigationTransitions {
                     }
                     router.browserUrlTree = t.urlAfterRedirects;
                 }
-            }), activateRoutes(this.rootContexts, router.routeReuseStrategy, (evt) => this.events.next(evt)), tap({
+            }), activateRoutes(this.rootContexts, router.routeReuseStrategy, (evt) => this.events.next(evt), this.inputBindingEnabled), 
+            // Ensure that if some observable used to drive the transition doesn't
+            // complete, the navigation still finalizes This should never happen, but
+            // this is done as a safety measure to avoid surfacing this error (#49567).
+            take(1), tap({
                 next: (t) => {
                     completed = true;
                     this.lastSuccessfulNavigation = this.currentNavigation;
@@ -4465,7 +4433,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 +4507,10 @@ class NavigationTransitions {
         this.events.next(navCancel);
         t.resolve(false);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: NavigationTransitions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", ngImport: i0, type: NavigationTransitions, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return []; } });
@@ -4593,10 +4561,10 @@ class TitleStrategy {
     getResolvedTitleForRoute(snapshot) {
         return snapshot.data[RouteTitleKey];
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: TitleStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", ngImport: i0, type: TitleStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root', useFactory: () => inject(DefaultTitleStrategy) }]
         }] });
@@ -4619,10 +4587,10 @@ class DefaultTitleStrategy extends TitleStrategy {
             this.title.setTitle(title);
         }
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", 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.6", ngImport: i0, type: DefaultTitleStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i1.Title }]; } });
@@ -4635,10 +4603,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.6", ngImport: i0, type: RouteReuseStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", ngImport: i0, type: RouteReuseStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root', useFactory: () => inject(DefaultRouteReuseStrategy) }]
         }] });
@@ -4689,21 +4657,20 @@ class BaseRouteReuseStrategy {
     }
 }
 class DefaultRouteReuseStrategy extends BaseRouteReuseStrategy {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: DefaultRouteReuseStrategy, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", 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 +4683,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.6", ngImport: i0, type: UrlHandlingStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", ngImport: i0, type: UrlHandlingStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root', useFactory: () => inject(DefaultUrlHandlingStrategy) }]
         }] });
@@ -4736,15 +4703,47 @@ class DefaultUrlHandlingStrategy {
     merge(newUrlPart, wholeUrl) {
         return newUrlPart;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: DefaultUrlHandlingStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", 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 +4820,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.
          *
@@ -4937,6 +4937,13 @@ class Router {
         this.navigationTransitions = inject(NavigationTransitions);
         this.urlSerializer = inject(UrlSerializer);
         this.location = inject(Location);
+        /**
+         * Indicates whether the the application has opted in to binding Router data to component inputs.
+         *
+         * This option is enabled by the `withComponentInputBinding` feature of `provideRouter` or
+         * `bindToComponentInputs` in the `ExtraOptions` of `RouterModule.forRoot`.
+         */
+        this.componentInputBindingEnabled = !!inject(INPUT_BINDER, { optional: true });
         this.isNgZoneEnabled = inject(NgZone) instanceof NgZone && NgZone.isInAngularZone();
         this.resetConfig(this.config);
         this.currentUrlTree = new UrlTree();
@@ -5054,7 +5061,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,13 +5196,10 @@ 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()'?`);
             }
-            if (url instanceof UrlTree && url._warnIfUsedForNavigation) {
-                this.console.warn(url._warnIfUsedForNavigation);
-            }
         }
         const urlTree = isUrlTree(url) ? url : this.parseUrl(url);
         const mergedTree = this.urlHandlingStrategy.merge(urlTree, this.rawUrlTree);
@@ -5318,6 +5322,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 +5427,10 @@ class Router {
         }
         return { navigationId };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: Router, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", ngImport: i0, type: Router, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return []; } });
@@ -5427,7 +5438,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 +5716,10 @@ class RouterLink {
             preserveFragment: this.preserveFragment,
         });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", 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.6", ngImport: i0, type: RouterLink, decorators: [{
             type: Directive,
             args: [{
                     selector: '[routerLink]',
@@ -5927,10 +5939,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.6", 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.6", 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.6", ngImport: i0, type: RouterLinkActive, decorators: [{
             type: Directive,
             args: [{
                     selector: '[routerLinkActive]',
@@ -5982,10 +5994,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.6", ngImport: i0, type: PreloadAllModules, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", ngImport: i0, type: PreloadAllModules, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -6002,10 +6014,10 @@ class NoPreloading {
     preload(route, fn) {
         return of(null);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: NoPreloading, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", ngImport: i0, type: NoPreloading, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -6064,7 +6076,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 +6110,10 @@ class RouterPreloader {
             }
         });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", 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.6", 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 +6206,13 @@ class RouterScroller {
         this.routerEventsSubscription?.unsubscribe();
         this.scrollEventsSubscription?.unsubscribe();
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", 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 +6252,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 +6306,7 @@ const routerIsProvidedDevModeCheck = {
 function provideRoutes(routes) {
     return [
         { provide: ROUTES, multi: true, useValue: routes },
-        NG_DEV_MODE$1 ? routerIsProvidedDevModeCheck : [],
+        (typeof ngDevMode === 'undefined' || ngDevMode) ? routerIsProvidedDevModeCheck : [],
     ];
 }
 /**
@@ -6384,6 +6364,7 @@ function getBootstrapListener() {
         router.resetRootComponentType(ref.componentTypes[0]);
         if (!bootstrapDone.closed) {
             bootstrapDone.next();
+            bootstrapDone.complete();
             bootstrapDone.unsubscribe();
         }
     };
@@ -6393,12 +6374,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 +6508,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 +6530,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`.
@@ -6690,8 +6671,34 @@ function withNavigationErrorHandler(fn) {
         }];
     return routerFeature(7 /* RouterFeatureKind.NavigationErrorHandlerFeature */, providers);
 }
+/**
+ * Enables binding information from the `Router` state directly to the inputs of the component in
+ * `Route` configurations.
+ *
+ * @usageNotes
+ *
+ * Basic example of how you can enable the feature:
+ * ```
+ * const appRoutes: Routes = [];
+ * bootstrapApplication(AppComponent,
+ *   {
+ *     providers: [
+ *       provideRouter(appRoutes, withComponentInputBinding())
+ *     ]
+ *   }
+ * );
+ * ```
+ *
+ * @returns A set of providers for use with `provideRouter`.
+ */
+function withComponentInputBinding() {
+    const providers = [
+        RoutedComponentInputBinder,
+        { provide: INPUT_BINDER, useExisting: RoutedComponentInputBinder },
+    ];
+    return routerFeature(8 /* RouterFeatureKind.ComponentInputBindingFeature */, providers);
+}
 
-const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
 /**
  * The directives defined in the `RouterModule`.
  */
@@ -6699,7 +6706,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 +6721,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 +6773,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,
@@ -6777,6 +6788,7 @@ class RouterModule {
                 config?.preloadingStrategy ? withPreloading(config.preloadingStrategy).ɵproviders : [],
                 { provide: NgProbeToken, multi: true, useFactory: routerNgProbeToken },
                 config?.initialNavigation ? provideInitialNavigation(config) : [],
+                config?.bindToComponentInputs ? withComponentInputBinding().ɵproviders : [],
                 provideRouterInitializer(),
             ],
         };
@@ -6803,11 +6815,11 @@ class RouterModule {
             providers: [{ provide: ROUTES, multi: true, useValue: routes }],
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.6", 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.6", 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.6", 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.6", ngImport: i0, type: RouterModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: ROUTER_DIRECTIVES,
@@ -6850,7 +6862,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 +6885,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 +6964,7 @@ function mapToResolve(provider) {
 /**
  * @publicApi
  */
-const VERSION = new Version('16.0.0-next.4');
+const VERSION = new Version('16.0.0-next.6');
 
 /**
  * @module
@@ -6967,5 +6979,5 @@ const VERSION = new Version('16.0.0-next.4');
  * Generated bundle index. Do not edit.
  */
 
-export { ActivatedRoute, ActivatedRouteSnapshot, ActivationEnd, ActivationStart, BaseRouteReuseStrategy, ChildActivationEnd, ChildActivationStart, ChildrenOutletContexts, DefaultTitleStrategy, DefaultUrlSerializer, GuardsCheckEnd, GuardsCheckStart, NavigationCancel, NavigationEnd, NavigationError, NavigationSkipped, NavigationStart, NoPreloading, OutletContext, PRIMARY_OUTLET, PreloadAllModules, PreloadingStrategy, ROUTER_CONFIGURATION, ROUTER_INITIALIZER, ROUTES, ResolveEnd, ResolveStart, RouteConfigLoadEnd, RouteConfigLoadStart, RouteReuseStrategy, Router, RouterEvent, RouterLink, RouterLinkActive, RouterLink as RouterLinkWithHref, RouterModule, RouterOutlet, RouterPreloader, RouterState, RouterStateSnapshot, RoutesRecognized, Scroll, TitleStrategy, UrlHandlingStrategy, UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree, VERSION, convertToParamMap, createUrlTreeFromSnapshot, defaultUrlMatcher, mapToCanActivate, mapToCanActivateChild, mapToCanDeactivate, mapToCanMatch, mapToResolve, provideRouter, provideRoutes, withDebugTracing, withDisabledInitialNavigation, withEnabledBlockingInitialNavigation, withHashLocation, withInMemoryScrolling, withNavigationErrorHandler, withPreloading, withRouterConfig, ɵEmptyOutletComponent, ROUTER_PROVIDERS as ɵROUTER_PROVIDERS, afterNextNavigation as ɵafterNextNavigation, withPreloading as ɵwithPreloading };
+export { ActivatedRoute, ActivatedRouteSnapshot, ActivationEnd, ActivationStart, BaseRouteReuseStrategy, ChildActivationEnd, ChildActivationStart, ChildrenOutletContexts, DefaultTitleStrategy, DefaultUrlSerializer, GuardsCheckEnd, GuardsCheckStart, NavigationCancel, NavigationEnd, NavigationError, NavigationSkipped, NavigationStart, NoPreloading, OutletContext, PRIMARY_OUTLET, PreloadAllModules, PreloadingStrategy, ROUTER_CONFIGURATION, ROUTER_INITIALIZER, ROUTES, ResolveEnd, ResolveStart, RouteConfigLoadEnd, RouteConfigLoadStart, RouteReuseStrategy, Router, RouterEvent, RouterLink, RouterLinkActive, RouterLink as RouterLinkWithHref, RouterModule, RouterOutlet, RouterPreloader, RouterState, RouterStateSnapshot, RoutesRecognized, Scroll, TitleStrategy, UrlHandlingStrategy, UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree, VERSION, convertToParamMap, createUrlTreeFromSnapshot, defaultUrlMatcher, mapToCanActivate, mapToCanActivateChild, mapToCanDeactivate, mapToCanMatch, mapToResolve, provideRouter, provideRoutes, withComponentInputBinding, withDebugTracing, withDisabledInitialNavigation, withEnabledBlockingInitialNavigation, withHashLocation, withInMemoryScrolling, withNavigationErrorHandler, withPreloading, withRouterConfig, ɵEmptyOutletComponent, ROUTER_PROVIDERS as ɵROUTER_PROVIDERS, afterNextNavigation as ɵafterNextNavigation, withPreloading as ɵwithPreloading };
 //# sourceMappingURL=router.mjs.map