@angular/router 15.0.0 → 15.0.2

package/fesm2015/router.mjs

@@ -1,11 +1,11 @@
 /**
- * @license Angular v15.0.0
+ * @license Angular v15.0.2
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
 
 import * as i0 from '@angular/core';
-import { ɵisObservable, ɵisPromise, ɵRuntimeError, Injectable, EventEmitter, inject, ViewContainerRef, ChangeDetectorRef, EnvironmentInjector, Directive, Input, Output, Component, createEnvironmentInjector, ɵisStandalone, ComponentFactoryResolver, ɵisInjectable, InjectionToken, InjectFlags, NgModuleFactory, Injector, Compiler, NgModuleRef, ɵConsole, NgZone, ɵcoerceToBoolean, ɵɵsanitizeUrlOrResourceUrl, Attribute, HostBinding, HostListener, Optional, ContentChildren, makeEnvironmentProviders, APP_BOOTSTRAP_LISTENER, ENVIRONMENT_INITIALIZER, ApplicationRef, APP_INITIALIZER, NgProbeToken, SkipSelf, NgModule, Inject, Version } from '@angular/core';
+import { ɵisObservable, ɵisPromise, ɵRuntimeError, Injectable, EventEmitter, inject, ViewContainerRef, ChangeDetectorRef, EnvironmentInjector, Directive, Input, Output, Component, createEnvironmentInjector, ɵisStandalone, ComponentFactoryResolver, ɵisInjectable, InjectionToken, InjectFlags, NgModuleFactory, Injector, Compiler, ɵConsole, NgZone, ɵcoerceToBoolean, ɵɵsanitizeUrlOrResourceUrl, Attribute, HostBinding, HostListener, Optional, ContentChildren, makeEnvironmentProviders, APP_BOOTSTRAP_LISTENER, ENVIRONMENT_INITIALIZER, ApplicationRef, APP_INITIALIZER, NgProbeToken, SkipSelf, NgModule, Inject, Version } from '@angular/core';
 import { from, of, BehaviorSubject, EmptyError, combineLatest, concat, defer, pipe, throwError, Observable, EMPTY, ConnectableObservable, Subject } from 'rxjs';
 import * as i3 from '@angular/common';
 import { Location, ViewportScroller, LOCATION_INITIALIZED, LocationStrategy, HashLocationStrategy, PathLocationStrategy } from '@angular/common';
@@ -202,7 +202,7 @@ function wrapIntoObservable(value) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-const NG_DEV_MODE$9 = typeof ngDevMode === 'undefined' || ngDevMode;
+const NG_DEV_MODE$a = typeof ngDevMode === 'undefined' || ngDevMode;
 const pathCompareMap = {
     'exact': equalSegmentGroups,
     'subset': containsSegmentGroup,
@@ -327,7 +327,7 @@ class UrlTree {
         this.root = root;
         this.queryParams = queryParams;
         this.fragment = fragment;
-        if (NG_DEV_MODE$9) {
+        if (NG_DEV_MODE$a) {
             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.');
@@ -461,9 +461,9 @@ function mapChildrenIntoArray(segment, fn) {
  */
 class UrlSerializer {
 }
-UrlSerializer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: UrlSerializer, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-UrlSerializer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: UrlSerializer, providedIn: 'root', useFactory: () => new DefaultUrlSerializer() });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: UrlSerializer, decorators: [{
+UrlSerializer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: UrlSerializer, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+UrlSerializer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: UrlSerializer, providedIn: 'root', useFactory: () => new DefaultUrlSerializer() });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: UrlSerializer, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root', useFactory: () => new DefaultUrlSerializer() }]
         }] });
@@ -675,7 +675,7 @@ class UrlParser {
     parseSegment() {
         const path = matchSegments(this.remaining);
         if (path === '' && this.peekStartsWith(';')) {
-            throw new ɵRuntimeError(4009 /* RuntimeErrorCode.EMPTY_PATH_WITH_PARAMS */, NG_DEV_MODE$9 && `Empty path url segment cannot have parameters: '${this.remaining}'.`);
+            throw new ɵRuntimeError(4009 /* RuntimeErrorCode.EMPTY_PATH_WITH_PARAMS */, NG_DEV_MODE$a && `Empty path url segment cannot have parameters: '${this.remaining}'.`);
         }
         this.capture(path);
         return new UrlSegment(decode(path), this.parseMatrixParams());
@@ -744,7 +744,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$9 && `Cannot parse url '${this.url}'`);
+                throw new ɵRuntimeError(4010 /* RuntimeErrorCode.UNPARSABLE_URL */, NG_DEV_MODE$a && `Cannot parse url '${this.url}'`);
             }
             let outletName = undefined;
             if (path.indexOf(':') > -1) {
@@ -775,7 +775,7 @@ class UrlParser {
     }
     capture(str) {
         if (!this.consumeOptional(str)) {
-            throw new ɵRuntimeError(4011 /* RuntimeErrorCode.UNEXPECTED_VALUE_IN_URL */, NG_DEV_MODE$9 && `Expected "${str}".`);
+            throw new ɵRuntimeError(4011 /* RuntimeErrorCode.UNEXPECTED_VALUE_IN_URL */, NG_DEV_MODE$a && `Expected "${str}".`);
         }
     }
 }
@@ -828,7 +828,7 @@ function isUrlTree(v) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-const NG_DEV_MODE$8 = typeof ngDevMode === 'undefined' || ngDevMode;
+const NG_DEV_MODE$9 = typeof ngDevMode === 'undefined' || ngDevMode;
 /**
  * Creates a `UrlTree` relative to an `ActivatedRouteSnapshot`.
  *
@@ -999,11 +999,11 @@ 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$8 && 'Root segment cannot have matrix parameters');
+            throw new ɵRuntimeError(4003 /* RuntimeErrorCode.ROOT_SEGMENT_MATRIX_PARAMS */, NG_DEV_MODE$9 && '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$8 && '{outlets:{}} has to be the last command');
+            throw new ɵRuntimeError(4004 /* RuntimeErrorCode.MISPLACED_OUTLETS_COMMAND */, NG_DEV_MODE$9 && '{outlets:{}} has to be the last command');
         }
     }
     toRoot() {
@@ -1102,7 +1102,7 @@ function createPositionApplyingDoubleDots(group, index, numberOfDoubleDots) {
         dd -= ci;
         g = g.parent;
         if (!g) {
-            throw new ɵRuntimeError(4005 /* RuntimeErrorCode.INVALID_DOUBLE_DOTS */, NG_DEV_MODE$8 && 'Invalid number of \'../\'');
+            throw new ɵRuntimeError(4005 /* RuntimeErrorCode.INVALID_DOUBLE_DOTS */, NG_DEV_MODE$9 && 'Invalid number of \'../\'');
         }
         ci = g.segments.length;
     }
@@ -2386,9 +2386,9 @@ class ChildrenOutletContexts {
         return this.contexts.get(childName) || null;
     }
 }
-ChildrenOutletContexts.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: ChildrenOutletContexts, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ChildrenOutletContexts.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: ChildrenOutletContexts, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: ChildrenOutletContexts, decorators: [{
+ChildrenOutletContexts.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ChildrenOutletContexts, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ChildrenOutletContexts.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ChildrenOutletContexts, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ChildrenOutletContexts, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -2400,7 +2400,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImpor
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-const NG_DEV_MODE$7 = typeof ngDevMode === 'undefined' || ngDevMode;
+const NG_DEV_MODE$8 = typeof ngDevMode === 'undefined' || ngDevMode;
 /**
  * @description
  *
@@ -2540,12 +2540,12 @@ class RouterOutlet {
      */
     get component() {
         if (!this.activated)
-            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$7 && 'Outlet is not activated');
+            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$8 && 'Outlet is not activated');
         return this.activated.instance;
     }
     get activatedRoute() {
         if (!this.activated)
-            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$7 && 'Outlet is not activated');
+            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$8 && 'Outlet is not activated');
         return this._activatedRoute;
     }
     get activatedRouteData() {
@@ -2559,7 +2559,7 @@ class RouterOutlet {
      */
     detach() {
         if (!this.activated)
-            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$7 && 'Outlet is not activated');
+            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$8 && 'Outlet is not activated');
         this.location.detach();
         const cmp = this.activated;
         this.activated = null;
@@ -2587,11 +2587,11 @@ class RouterOutlet {
     }
     activateWith(activatedRoute, resolverOrInjector) {
         if (this.isActivated) {
-            throw new ɵRuntimeError(4013 /* RuntimeErrorCode.OUTLET_ALREADY_ACTIVATED */, NG_DEV_MODE$7 && 'Cannot activate an already activated outlet');
+            throw new ɵRuntimeError(4013 /* RuntimeErrorCode.OUTLET_ALREADY_ACTIVATED */, NG_DEV_MODE$8 && 'Cannot activate an already activated outlet');
         }
         this._activatedRoute = activatedRoute;
         const location = this.location;
-        const snapshot = activatedRoute._futureSnapshot;
+        const snapshot = activatedRoute.snapshot;
         const component = snapshot.component;
         const childContexts = this.parentContexts.getOrCreateContext(this.name).children;
         const injector = new OutletInjector(activatedRoute, childContexts, location.injector);
@@ -2609,9 +2609,9 @@ class RouterOutlet {
         this.activateEvents.emit(this.activated.instance);
     }
 }
-RouterOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: RouterOutlet, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-RouterOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", 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: "15.0.0", ngImport: i0, type: RouterOutlet, decorators: [{
+RouterOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouterOutlet, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+RouterOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", 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: "15.0.2", ngImport: i0, type: RouterOutlet, decorators: [{
             type: Directive,
             args: [{
                     selector: 'router-outlet',
@@ -2671,9 +2671,9 @@ function isComponentFactoryResolver(item) {
  */
 class ɵEmptyOutletComponent {
 }
-ɵEmptyOutletComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-ɵEmptyOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.0", 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: "15.0.0", ngImport: i0, type: ɵEmptyOutletComponent, decorators: [{
+ɵEmptyOutletComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ɵEmptyOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.2", 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: "15.0.2", ngImport: i0, type: ɵEmptyOutletComponent, decorators: [{
             type: Component,
             args: [{
                     template: `<router-outlet></router-outlet>`,
@@ -3591,7 +3591,7 @@ function noLeftoversInUrl(segmentGroup, segments, outlet) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-const NG_DEV_MODE$6 = typeof ngDevMode === 'undefined' || ngDevMode;
+const NG_DEV_MODE$7 = typeof ngDevMode === 'undefined' || ngDevMode;
 class NoMatch$1 {
     constructor(segmentGroup) {
         this.segmentGroup = segmentGroup || null;
@@ -3609,11 +3609,11 @@ function absoluteRedirect(newTree) {
     return throwError(new AbsoluteRedirect(newTree));
 }
 function namedOutletsRedirect(redirectTo) {
-    return throwError(new ɵRuntimeError(4000 /* RuntimeErrorCode.NAMED_OUTLET_REDIRECT */, NG_DEV_MODE$6 &&
+    return throwError(new ɵRuntimeError(4000 /* RuntimeErrorCode.NAMED_OUTLET_REDIRECT */, NG_DEV_MODE$7 &&
         `Only absolute redirects can have named outlets. redirectTo: '${redirectTo}'`));
 }
 function canLoadFails(route) {
-    return throwError(navigationCancelingError(NG_DEV_MODE$6 &&
+    return throwError(navigationCancelingError(NG_DEV_MODE$7 &&
         `Cannot load children because the guard of the route "path: '${route.path}'" returned false`, 3 /* NavigationCancellationCode.GuardRejected */));
 }
 /**
@@ -3673,7 +3673,7 @@ class ApplyRedirects {
         }));
     }
     noMatchError(e) {
-        return new ɵRuntimeError(4002 /* RuntimeErrorCode.NO_MATCH */, NG_DEV_MODE$6 && `Cannot match any routes. URL Segment: '${e.segmentGroup}'`);
+        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);
@@ -3890,7 +3890,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$6 &&
+            throw new ɵRuntimeError(4001 /* RuntimeErrorCode.MISSING_REDIRECT */, NG_DEV_MODE$7 &&
                 `Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);
         return pos;
     }
@@ -3926,7 +3926,7 @@ function applyRedirects(environmentInjector, configLoader, urlSerializer, config
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-const NG_DEV_MODE$5 = typeof ngDevMode === 'undefined' || !!ngDevMode;
+const NG_DEV_MODE$6 = typeof ngDevMode === 'undefined' || !!ngDevMode;
 class NoMatch {
 }
 function newObservableError(e) {
@@ -4014,7 +4014,7 @@ class Recognizer {
             // 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$5) {
+            if (NG_DEV_MODE$6) {
                 // This should really never happen - we are only taking the first match for each
                 // outlet and merge the empty path matches.
                 checkOutletNameUniqueness(mergedChildren);
@@ -4173,7 +4173,7 @@ 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$5 && `Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
+            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}'.`);
         }
         names[n.value.outlet] = n.value;
     });
@@ -4314,174 +4314,8 @@ function switchTap(next) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-/**
- * Provides a strategy for setting the page title after a router navigation.
- *
- * The built-in implementation traverses the router state snapshot and finds the deepest primary
- * outlet with `title` property. Given the `Routes` below, navigating to
- * `/base/child(popup:aux)` would result in the document title being set to "child".
- * ```
- * [
- *   {path: 'base', title: 'base', children: [
- *     {path: 'child', title: 'child'},
- *   ],
- *   {path: 'aux', outlet: 'popup', title: 'popupTitle'}
- * ]
- * ```
- *
- * This class can be used as a base class for custom title strategies. That is, you can create your
- * own class that extends the `TitleStrategy`. Note that in the above example, the `title`
- * from the named outlet is never used. However, a custom strategy might be implemented to
- * incorporate titles in named outlets.
- *
- * @publicApi
- * @see [Page title guide](guide/router#setting-the-page-title)
- */
-class TitleStrategy {
-    /**
-     * @returns The `title` of the deepest primary route.
-     */
-    buildTitle(snapshot) {
-        var _a;
-        let pageTitle;
-        let route = snapshot.root;
-        while (route !== undefined) {
-            pageTitle = (_a = this.getResolvedTitleForRoute(route)) !== null && _a !== void 0 ? _a : pageTitle;
-            route = route.children.find(child => child.outlet === PRIMARY_OUTLET);
-        }
-        return pageTitle;
-    }
-    /**
-     * Given an `ActivatedRouteSnapshot`, returns the final value of the
-     * `Route.title` property, which can either be a static string or a resolved value.
-     */
-    getResolvedTitleForRoute(snapshot) {
-        return snapshot.data[RouteTitleKey];
-    }
-}
-TitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: TitleStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-TitleStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: TitleStrategy, providedIn: 'root', useFactory: () => inject(DefaultTitleStrategy) });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: TitleStrategy, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root', useFactory: () => inject(DefaultTitleStrategy) }]
-        }] });
-/**
- * The default `TitleStrategy` used by the router that updates the title using the `Title` service.
- */
-class DefaultTitleStrategy extends TitleStrategy {
-    constructor(title) {
-        super();
-        this.title = title;
-    }
-    /**
-     * Sets the title of the browser to the given value.
-     *
-     * @param title The `pageTitle` from the deepest primary route.
-     */
-    updateTitle(snapshot) {
-        const title = this.buildTitle(snapshot);
-        if (title !== undefined) {
-            this.title.setTitle(title);
-        }
-    }
-}
-DefaultTitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: DefaultTitleStrategy, deps: [{ token: i1.Title }], target: i0.ɵɵFactoryTarget.Injectable });
-DefaultTitleStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: DefaultTitleStrategy, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: DefaultTitleStrategy, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: i1.Title }]; } });
-
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-/**
- * @description
- *
- * Provides a way to customize when activated routes get reused.
- *
- * @publicApi
- */
-class RouteReuseStrategy {
-}
-/**
- * @description
- *
- * This base route reuse strategy only reuses routes when the matched router configs are
- * identical. This prevents components from being destroyed and recreated
- * when just the route parameters, query parameters or fragment change
- * (that is, the existing component is _reused_).
- *
- * This strategy does not store any routes for later reuse.
- *
- * Angular uses this strategy by default.
- *
- *
- * It can be used as a base class for custom route reuse strategies, i.e. you can create your own
- * class that extends the `BaseRouteReuseStrategy` one.
- * @publicApi
- */
-class BaseRouteReuseStrategy {
-    /**
-     * Whether the given route should detach for later reuse.
-     * Always returns false for `BaseRouteReuseStrategy`.
-     * */
-    shouldDetach(route) {
-        return false;
-    }
-    /**
-     * A no-op; the route is never stored since this strategy never detaches routes for later re-use.
-     */
-    store(route, detachedTree) { }
-    /** Returns `false`, meaning the route (and its subtree) is never reattached */
-    shouldAttach(route) {
-        return false;
-    }
-    /** Returns `null` because this strategy does not store routes for later re-use. */
-    retrieve(route) {
-        return null;
-    }
-    /**
-     * Determines if a route should be reused.
-     * This strategy returns `true` when the future route config and current route config are
-     * identical.
-     */
-    shouldReuseRoute(future, curr) {
-        return future.routeConfig === curr.routeConfig;
-    }
-}
-class DefaultRouteReuseStrategy extends BaseRouteReuseStrategy {
-}
-
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-const NG_DEV_MODE$4 = typeof ngDevMode === 'undefined' || !!ngDevMode;
-/**
- * A [DI token](guide/glossary/#di-token) for the router service.
- *
- * @publicApi
- */
-const ROUTER_CONFIGURATION = new InjectionToken(NG_DEV_MODE$4 ? 'router config' : '', {
-    providedIn: 'root',
-    factory: () => ({}),
-});
-
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
+// This file exists to support the legacy `loadChildren: string` behavior being patched back into
+// Angular.
 function deprecatedLoadChildrenString(injector, loadChildren) {
     return null;
 }
@@ -4493,7 +4327,7 @@ function deprecatedLoadChildrenString(injector, loadChildren) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-const NG_DEV_MODE$3 = typeof ngDevMode === 'undefined' || !!ngDevMode;
+const NG_DEV_MODE$5 = typeof ngDevMode === 'undefined' || !!ngDevMode;
 /**
  * The [DI token](guide/glossary/#di-token) for a router configuration.
  *
@@ -4528,7 +4362,7 @@ class RouterConfigLoader {
             if (this.onLoadEndListener) {
                 this.onLoadEndListener(route);
             }
-            NG_DEV_MODE$3 && assertStandalone((_a = route.path) !== null && _a !== void 0 ? _a : '', component);
+            NG_DEV_MODE$5 && assertStandalone((_a = route.path) !== null && _a !== void 0 ? _a : '', component);
             route._loadedComponent = component;
         }), finalize(() => {
             this.componentLoaders.delete(route);
@@ -4571,7 +4405,7 @@ class RouterConfigLoader {
                 rawRoutes = flatten(injector.get(ROUTES, [], InjectFlags.Self | InjectFlags.Optional));
             }
             const routes = rawRoutes.map(standardizeConfig);
-            NG_DEV_MODE$3 && validateConfig(routes, route.path, requireStandaloneComponents);
+            NG_DEV_MODE$5 && validateConfig(routes, route.path, requireStandaloneComponents);
             return { routes, injector };
         }), finalize(() => {
             this.childrenLoaders.delete(route);
@@ -4598,9 +4432,9 @@ class RouterConfigLoader {
         }));
     }
 }
-RouterConfigLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: RouterConfigLoader, deps: [{ token: i0.Injector }, { token: i0.Compiler }], target: i0.ɵɵFactoryTarget.Injectable });
-RouterConfigLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: RouterConfigLoader, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: RouterConfigLoader, decorators: [{
+RouterConfigLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouterConfigLoader, deps: [{ token: i0.Injector }, { token: i0.Compiler }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterConfigLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouterConfigLoader, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouterConfigLoader, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.Compiler }]; } });
@@ -4623,84 +4457,631 @@ function maybeUnwrapDefaultExport(input) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-/**
- * @description
- *
- * Provides a way to migrate AngularJS applications to Angular.
- *
- * @publicApi
- */
-class UrlHandlingStrategy {
-}
-/**
- * @publicApi
- */
-class DefaultUrlHandlingStrategy {
-    shouldProcessUrl(url) {
-        return true;
-    }
-    extract(url) {
-        return url;
-    }
-    merge(newUrlPart, wholeUrl) {
-        return newUrlPart;
-    }
-}
-
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-const NG_DEV_MODE$2 = typeof ngDevMode === 'undefined' || !!ngDevMode;
-function defaultErrorHandler(error) {
-    throw error;
-}
-function defaultMalformedUriErrorHandler(error, urlSerializer, url) {
-    return urlSerializer.parse('/');
-}
-/**
- * The equivalent `IsActiveMatchOptions` options for `Router.isActive` is called with `true`
- * (exact = true).
- */
-const exactMatchOptions = {
-    paths: 'exact',
-    fragment: 'ignored',
-    matrixParams: 'ignored',
-    queryParams: 'exact'
-};
-/**
- * The equivalent `IsActiveMatchOptions` options for `Router.isActive` is called with `false`
- * (exact = false).
- */
-const subsetMatchOptions = {
-    paths: 'subset',
-    fragment: 'ignored',
-    matrixParams: 'ignored',
-    queryParams: 'subset'
-};
-function assignExtraOptionsToRouter(opts, router) {
-    if (opts.errorHandler) {
-        router.errorHandler = opts.errorHandler;
-    }
-    if (opts.malformedUriErrorHandler) {
-        router.malformedUriErrorHandler = opts.malformedUriErrorHandler;
-    }
-    if (opts.onSameUrlNavigation) {
-        router.onSameUrlNavigation = opts.onSameUrlNavigation;
+const NG_DEV_MODE$4 = typeof ngDevMode === 'undefined' || !!ngDevMode;
+class NavigationTransitions {
+    constructor() {
+        this.currentNavigation = null;
+        this.lastSuccessfulNavigation = null;
+        this.events = new Subject();
+        this.configLoader = inject(RouterConfigLoader);
+        this.environmentInjector = inject(EnvironmentInjector);
+        this.urlSerializer = inject(UrlSerializer);
+        this.rootContexts = inject(ChildrenOutletContexts);
+        this.navigationId = 0;
+        const onLoadStart = (r) => this.events.next(new RouteConfigLoadStart(r));
+        const onLoadEnd = (r) => this.events.next(new RouteConfigLoadEnd(r));
+        this.configLoader.onLoadEndListener = onLoadEnd;
+        this.configLoader.onLoadStartListener = onLoadStart;
     }
-    if (opts.paramsInheritanceStrategy) {
-        router.paramsInheritanceStrategy = opts.paramsInheritanceStrategy;
+    get hasRequestedNavigation() {
+        return this.navigationId !== 0;
     }
-    if (opts.urlUpdateStrategy) {
-        router.urlUpdateStrategy = opts.urlUpdateStrategy;
+    complete() {
+        var _a;
+        (_a = this.transitions) === null || _a === void 0 ? void 0 : _a.complete();
     }
-    if (opts.canceledNavigationResolution) {
-        router.canceledNavigationResolution = opts.canceledNavigationResolution;
+    handleNavigationRequest(request) {
+        var _a;
+        const id = ++this.navigationId;
+        (_a = this.transitions) === null || _a === void 0 ? void 0 : _a.next(Object.assign(Object.assign(Object.assign({}, this.transitions.value), request), { id }));
     }
-}
+    setupNavigations(router) {
+        this.transitions = new BehaviorSubject({
+            id: 0,
+            targetPageId: 0,
+            currentUrlTree: router.currentUrlTree,
+            currentRawUrl: router.currentUrlTree,
+            extractedUrl: router.urlHandlingStrategy.extract(router.currentUrlTree),
+            urlAfterRedirects: router.urlHandlingStrategy.extract(router.currentUrlTree),
+            rawUrl: router.currentUrlTree,
+            extras: {},
+            resolve: null,
+            reject: null,
+            promise: Promise.resolve(true),
+            source: 'imperative',
+            restoredState: null,
+            currentSnapshot: router.routerState.snapshot,
+            targetSnapshot: null,
+            currentRouterState: router.routerState,
+            targetRouterState: null,
+            guards: { canActivateChecks: [], canDeactivateChecks: [] },
+            guardsResult: null,
+        });
+        return this.transitions.pipe(filter(t => t.id !== 0), 
+        // Extract URL
+        map(t => (Object.assign(Object.assign({}, t), { extractedUrl: router.urlHandlingStrategy.extract(t.rawUrl) }))), 
+        // Using switchMap so we cancel executing navigations when a new one comes in
+        switchMap(overallTransitionState => {
+            let completed = false;
+            let errored = false;
+            return of(overallTransitionState)
+                .pipe(
+            // Store the Navigation object
+            tap(t => {
+                this.currentNavigation = {
+                    id: t.id,
+                    initialUrl: t.rawUrl,
+                    extractedUrl: t.extractedUrl,
+                    trigger: t.source,
+                    extras: t.extras,
+                    previousNavigation: !this.lastSuccessfulNavigation ? null : Object.assign(Object.assign({}, this.lastSuccessfulNavigation), { previousNavigation: null }),
+                };
+            }), switchMap(t => {
+                const browserUrlTree = router.browserUrlTree.toString();
+                const urlTransition = !router.navigated ||
+                    t.extractedUrl.toString() !== browserUrlTree ||
+                    // Navigations which succeed or ones which fail and are cleaned up
+                    // correctly should result in `browserUrlTree` and `currentUrlTree`
+                    // matching. If this is not the case, assume something went wrong and
+                    // try processing the URL again.
+                    browserUrlTree !== router.currentUrlTree.toString();
+                const processCurrentUrl = (router.onSameUrlNavigation === 'reload' ? true : urlTransition) &&
+                    router.urlHandlingStrategy.shouldProcessUrl(t.rawUrl);
+                if (processCurrentUrl) {
+                    // If the source of the navigation is from a browser event, the URL is
+                    // already updated. We already need to sync the internal state.
+                    if (isBrowserTriggeredNavigation(t.source)) {
+                        router.browserUrlTree = t.extractedUrl;
+                    }
+                    return of(t).pipe(
+                    // Fire NavigationStart event
+                    switchMap(t => {
+                        var _a, _b;
+                        const transition = (_a = this.transitions) === null || _a === void 0 ? void 0 : _a.getValue();
+                        this.events.next(new NavigationStart(t.id, this.urlSerializer.serialize(t.extractedUrl), t.source, t.restoredState));
+                        if (transition !== ((_b = this.transitions) === null || _b === void 0 ? void 0 : _b.getValue())) {
+                            return EMPTY;
+                        }
+                        // This delay is required to match old behavior that forced
+                        // 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
+                    tap(t => {
+                        this.currentNavigation = Object.assign(Object.assign({}, this.currentNavigation), { finalUrl: t.urlAfterRedirects });
+                        overallTransitionState.urlAfterRedirects = t.urlAfterRedirects;
+                    }), 
+                    // Recognize
+                    recognize(this.environmentInjector, router.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);
+                                router.setBrowserUrl(rawUrl, t);
+                            }
+                            router.browserUrlTree = t.urlAfterRedirects;
+                        }
+                        // Fire RoutesRecognized
+                        const routesRecognized = new RoutesRecognized(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot);
+                        this.events.next(routesRecognized);
+                    }));
+                }
+                else {
+                    const processPreviousUrl = urlTransition && router.rawUrlTree &&
+                        router.urlHandlingStrategy.shouldProcessUrl(router.rawUrlTree);
+                    /* When the current URL shouldn't be processed, but the previous one
+                     * was, we handle this "error condition" by navigating to the
+                     * previously successful URL, but leaving the URL intact.*/
+                    if (processPreviousUrl) {
+                        const { id, extractedUrl, source, restoredState, extras } = t;
+                        const navStart = new NavigationStart(id, this.urlSerializer.serialize(extractedUrl), source, restoredState);
+                        this.events.next(navStart);
+                        const targetSnapshot = createEmptyState(extractedUrl, router.rootComponentType)
+                            .snapshot;
+                        overallTransitionState = Object.assign(Object.assign({}, t), { targetSnapshot, urlAfterRedirects: extractedUrl, extras: Object.assign(Object.assign({}, extras), { skipLocationChange: false, replaceUrl: false }) });
+                        return of(overallTransitionState);
+                    }
+                    else {
+                        /* When neither the current or previous URL can be processed, do
+                         * nothing other than update router's internal reference to the
+                         * current "settled" URL. This way the next navigation will be coming
+                         * from the current URL in the browser.
+                         */
+                        router.rawUrlTree = t.rawUrl;
+                        t.resolve(null);
+                        return EMPTY;
+                    }
+                }
+            }), 
+            // --- GUARDS ---
+            tap(t => {
+                const guardsStart = new GuardsCheckStart(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot);
+                this.events.next(guardsStart);
+            }), map(t => {
+                overallTransitionState = Object.assign(Object.assign({}, t), { guards: getAllRouteGuards(t.targetSnapshot, t.currentSnapshot, this.rootContexts) });
+                return overallTransitionState;
+            }), checkGuards(this.environmentInjector, (evt) => this.events.next(evt)), tap(t => {
+                overallTransitionState.guardsResult = t.guardsResult;
+                if (isUrlTree(t.guardsResult)) {
+                    throw redirectingNavigationError(this.urlSerializer, t.guardsResult);
+                }
+                const guardsEnd = new GuardsCheckEnd(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot, !!t.guardsResult);
+                this.events.next(guardsEnd);
+            }), filter(t => {
+                if (!t.guardsResult) {
+                    router.restoreHistory(t);
+                    this.cancelNavigationTransition(t, '', 3 /* NavigationCancellationCode.GuardRejected */, router);
+                    return false;
+                }
+                return true;
+            }), 
+            // --- RESOLVE ---
+            switchTap(t => {
+                if (t.guards.canActivateChecks.length) {
+                    return of(t).pipe(tap(t => {
+                        const resolveStart = new ResolveStart(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot);
+                        this.events.next(resolveStart);
+                    }), switchMap(t => {
+                        let dataResolved = false;
+                        return of(t).pipe(resolveData(router.paramsInheritanceStrategy, this.environmentInjector), tap({
+                            next: () => dataResolved = true,
+                            complete: () => {
+                                if (!dataResolved) {
+                                    router.restoreHistory(t);
+                                    this.cancelNavigationTransition(t, NG_DEV_MODE$4 ?
+                                        `At least one route resolver didn't emit any value.` :
+                                        '', 2 /* NavigationCancellationCode.NoDataFromResolver */, router);
+                                }
+                            }
+                        }));
+                    }), tap(t => {
+                        const resolveEnd = new ResolveEnd(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot);
+                        this.events.next(resolveEnd);
+                    }));
+                }
+                return undefined;
+            }), 
+            // --- LOAD COMPONENTS ---
+            switchTap((t) => {
+                const loadComponents = (route) => {
+                    var _a;
+                    const loaders = [];
+                    if (((_a = route.routeConfig) === null || _a === void 0 ? void 0 : _a.loadComponent) &&
+                        !route.routeConfig._loadedComponent) {
+                        loaders.push(this.configLoader.loadComponent(route.routeConfig)
+                            .pipe(tap(loadedComponent => {
+                            route.component = loadedComponent;
+                        }), map(() => void 0)));
+                    }
+                    for (const child of route.children) {
+                        loaders.push(...loadComponents(child));
+                    }
+                    return loaders;
+                };
+                return combineLatest(loadComponents(t.targetSnapshot.root))
+                    .pipe(defaultIfEmpty(), take(1));
+            }), switchTap(() => router.afterPreactivation()), map((t) => {
+                const targetRouterState = createRouterState(router.routeReuseStrategy, t.targetSnapshot, t.currentRouterState);
+                overallTransitionState = Object.assign(Object.assign({}, t), { targetRouterState });
+                return (overallTransitionState);
+            }), 
+            /* Once here, we are about to activate synchronously. The assumption is
+               this will succeed, and user code may read from the Router service.
+               Therefore before activation, we need to update router properties storing
+               the current URL and the RouterState, as well as updated the browser URL.
+               All this should happen *before* activating. */
+            tap((t) => {
+                router.currentUrlTree = t.urlAfterRedirects;
+                router.rawUrlTree =
+                    router.urlHandlingStrategy.merge(t.urlAfterRedirects, t.rawUrl);
+                router.routerState =
+                    t.targetRouterState;
+                if (router.urlUpdateStrategy === 'deferred') {
+                    if (!t.extras.skipLocationChange) {
+                        router.setBrowserUrl(router.rawUrlTree, t);
+                    }
+                    router.browserUrlTree = t.urlAfterRedirects;
+                }
+            }), activateRoutes(this.rootContexts, router.routeReuseStrategy, (evt) => this.events.next(evt)), tap({
+                next: (t) => {
+                    var _a;
+                    completed = true;
+                    this.lastSuccessfulNavigation = this.currentNavigation;
+                    router.navigated = true;
+                    this.events.next(new NavigationEnd(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(router.currentUrlTree)));
+                    (_a = router.titleStrategy) === null || _a === void 0 ? void 0 : _a.updateTitle(t.targetRouterState.snapshot);
+                    t.resolve(true);
+                },
+                complete: () => {
+                    completed = true;
+                }
+            }), finalize(() => {
+                var _a;
+                /* When the navigation stream finishes either through error or success,
+                 * we set the `completed` or `errored` flag. However, there are some
+                 * situations where we could get here without either of those being set.
+                 * For instance, a redirect during NavigationStart. Therefore, this is a
+                 * 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 ?
+                        `Navigation ID ${overallTransitionState
+                            .id} is not equal to the current navigation id ${this.navigationId}` :
+                        '';
+                    this.cancelNavigationTransition(overallTransitionState, cancelationReason, 1 /* NavigationCancellationCode.SupersededByNewNavigation */, router);
+                }
+                // Only clear current navigation if it is still set to the one that
+                // finalized.
+                if (((_a = this.currentNavigation) === null || _a === void 0 ? void 0 : _a.id) === overallTransitionState.id) {
+                    this.currentNavigation = null;
+                }
+            }), catchError((e) => {
+                var _a;
+                errored = true;
+                /* This error type is issued during Redirect, and is handled as a
+                 * cancellation rather than an error. */
+                if (isNavigationCancelingError$1(e)) {
+                    if (!isRedirectingNavigationCancelingError$1(e)) {
+                        // Set property only if we're not redirecting. If we landed on a page
+                        // and redirect to `/` route, the new navigation is going to see the
+                        // `/` isn't a change from the default currentUrlTree and won't
+                        // navigate. This is only applicable with initial navigation, so
+                        // setting `navigated` only when not redirecting resolves this
+                        // scenario.
+                        router.navigated = true;
+                        router.restoreHistory(overallTransitionState, true);
+                    }
+                    const navCancel = new NavigationCancel(overallTransitionState.id, this.urlSerializer.serialize(overallTransitionState.extractedUrl), e.message, e.cancellationCode);
+                    this.events.next(navCancel);
+                    // When redirecting, we need to delay resolving the navigation
+                    // promise and push it to the redirect navigation
+                    if (!isRedirectingNavigationCancelingError$1(e)) {
+                        overallTransitionState.resolve(false);
+                    }
+                    else {
+                        const mergedTree = router.urlHandlingStrategy.merge(e.url, router.rawUrlTree);
+                        const extras = {
+                            skipLocationChange: overallTransitionState.extras.skipLocationChange,
+                            // The URL is already updated at this point if we have 'eager' URL
+                            // updates or if the navigation was triggered by the browser (back
+                            // button, URL bar, etc). We want to replace that item in history
+                            // if the navigation is rejected.
+                            replaceUrl: router.urlUpdateStrategy === 'eager' ||
+                                isBrowserTriggeredNavigation(overallTransitionState.source)
+                        };
+                        router.scheduleNavigation(mergedTree, 'imperative', null, extras, {
+                            resolve: overallTransitionState.resolve,
+                            reject: overallTransitionState.reject,
+                            promise: overallTransitionState.promise
+                        });
+                    }
+                    /* All other errors should reset to the router's internal URL reference
+                     * to the pre-error state. */
+                }
+                else {
+                    router.restoreHistory(overallTransitionState, true);
+                    const navError = new NavigationError(overallTransitionState.id, this.urlSerializer.serialize(overallTransitionState.extractedUrl), e, (_a = overallTransitionState.targetSnapshot) !== null && _a !== void 0 ? _a : undefined);
+                    this.events.next(navError);
+                    try {
+                        overallTransitionState.resolve(router.errorHandler(e));
+                    }
+                    catch (ee) {
+                        overallTransitionState.reject(ee);
+                    }
+                }
+                return EMPTY;
+            }));
+            // TODO(jasonaden): remove cast once g3 is on updated TypeScript
+        }));
+    }
+    cancelNavigationTransition(t, reason, code, router) {
+        const navCancel = new NavigationCancel(t.id, this.urlSerializer.serialize(t.extractedUrl), reason, code);
+        this.events.next(navCancel);
+        t.resolve(false);
+    }
+}
+NavigationTransitions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: NavigationTransitions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NavigationTransitions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: NavigationTransitions, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: NavigationTransitions, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+function isBrowserTriggeredNavigation(source) {
+    return source !== 'imperative';
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Provides a strategy for setting the page title after a router navigation.
+ *
+ * The built-in implementation traverses the router state snapshot and finds the deepest primary
+ * outlet with `title` property. Given the `Routes` below, navigating to
+ * `/base/child(popup:aux)` would result in the document title being set to "child".
+ * ```
+ * [
+ *   {path: 'base', title: 'base', children: [
+ *     {path: 'child', title: 'child'},
+ *   ],
+ *   {path: 'aux', outlet: 'popup', title: 'popupTitle'}
+ * ]
+ * ```
+ *
+ * This class can be used as a base class for custom title strategies. That is, you can create your
+ * own class that extends the `TitleStrategy`. Note that in the above example, the `title`
+ * from the named outlet is never used. However, a custom strategy might be implemented to
+ * incorporate titles in named outlets.
+ *
+ * @publicApi
+ * @see [Page title guide](guide/router#setting-the-page-title)
+ */
+class TitleStrategy {
+    /**
+     * @returns The `title` of the deepest primary route.
+     */
+    buildTitle(snapshot) {
+        var _a;
+        let pageTitle;
+        let route = snapshot.root;
+        while (route !== undefined) {
+            pageTitle = (_a = this.getResolvedTitleForRoute(route)) !== null && _a !== void 0 ? _a : pageTitle;
+            route = route.children.find(child => child.outlet === PRIMARY_OUTLET);
+        }
+        return pageTitle;
+    }
+    /**
+     * Given an `ActivatedRouteSnapshot`, returns the final value of the
+     * `Route.title` property, which can either be a static string or a resolved value.
+     */
+    getResolvedTitleForRoute(snapshot) {
+        return snapshot.data[RouteTitleKey];
+    }
+}
+TitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TitleStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TitleStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TitleStrategy, providedIn: 'root', useFactory: () => inject(DefaultTitleStrategy) });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TitleStrategy, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root', useFactory: () => inject(DefaultTitleStrategy) }]
+        }] });
+/**
+ * The default `TitleStrategy` used by the router that updates the title using the `Title` service.
+ */
+class DefaultTitleStrategy extends TitleStrategy {
+    constructor(title) {
+        super();
+        this.title = title;
+    }
+    /**
+     * Sets the title of the browser to the given value.
+     *
+     * @param title The `pageTitle` from the deepest primary route.
+     */
+    updateTitle(snapshot) {
+        const title = this.buildTitle(snapshot);
+        if (title !== undefined) {
+            this.title.setTitle(title);
+        }
+    }
+}
+DefaultTitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DefaultTitleStrategy, deps: [{ token: i1.Title }], target: i0.ɵɵFactoryTarget.Injectable });
+DefaultTitleStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DefaultTitleStrategy, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DefaultTitleStrategy, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Title }]; } });
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @description
+ *
+ * Provides a way to customize when activated routes get reused.
+ *
+ * @publicApi
+ */
+class RouteReuseStrategy {
+}
+RouteReuseStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouteReuseStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+RouteReuseStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouteReuseStrategy, providedIn: 'root', useFactory: () => inject(DefaultRouteReuseStrategy) });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouteReuseStrategy, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root', useFactory: () => inject(DefaultRouteReuseStrategy) }]
+        }] });
+/**
+ * @description
+ *
+ * This base route reuse strategy only reuses routes when the matched router configs are
+ * identical. This prevents components from being destroyed and recreated
+ * when just the route parameters, query parameters or fragment change
+ * (that is, the existing component is _reused_).
+ *
+ * This strategy does not store any routes for later reuse.
+ *
+ * Angular uses this strategy by default.
+ *
+ *
+ * It can be used as a base class for custom route reuse strategies, i.e. you can create your own
+ * class that extends the `BaseRouteReuseStrategy` one.
+ * @publicApi
+ */
+class BaseRouteReuseStrategy {
+    /**
+     * Whether the given route should detach for later reuse.
+     * Always returns false for `BaseRouteReuseStrategy`.
+     * */
+    shouldDetach(route) {
+        return false;
+    }
+    /**
+     * A no-op; the route is never stored since this strategy never detaches routes for later re-use.
+     */
+    store(route, detachedTree) { }
+    /** Returns `false`, meaning the route (and its subtree) is never reattached */
+    shouldAttach(route) {
+        return false;
+    }
+    /** Returns `null` because this strategy does not store routes for later re-use. */
+    retrieve(route) {
+        return null;
+    }
+    /**
+     * Determines if a route should be reused.
+     * This strategy returns `true` when the future route config and current route config are
+     * identical.
+     */
+    shouldReuseRoute(future, curr) {
+        return future.routeConfig === curr.routeConfig;
+    }
+}
+class DefaultRouteReuseStrategy extends BaseRouteReuseStrategy {
+}
+DefaultRouteReuseStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DefaultRouteReuseStrategy, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+DefaultRouteReuseStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DefaultRouteReuseStrategy, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DefaultRouteReuseStrategy, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+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' : '', {
+    providedIn: 'root',
+    factory: () => ({}),
+});
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @description
+ *
+ * Provides a way to migrate AngularJS applications to Angular.
+ *
+ * @publicApi
+ */
+class UrlHandlingStrategy {
+}
+UrlHandlingStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: UrlHandlingStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+UrlHandlingStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: UrlHandlingStrategy, providedIn: 'root', useFactory: () => inject(DefaultUrlHandlingStrategy) });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: UrlHandlingStrategy, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root', useFactory: () => inject(DefaultUrlHandlingStrategy) }]
+        }] });
+/**
+ * @publicApi
+ */
+class DefaultUrlHandlingStrategy {
+    shouldProcessUrl(url) {
+        return true;
+    }
+    extract(url) {
+        return url;
+    }
+    merge(newUrlPart, wholeUrl) {
+        return newUrlPart;
+    }
+}
+DefaultUrlHandlingStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DefaultUrlHandlingStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DefaultUrlHandlingStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DefaultUrlHandlingStrategy, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DefaultUrlHandlingStrategy, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+const NG_DEV_MODE$2 = typeof ngDevMode === 'undefined' || !!ngDevMode;
+function defaultErrorHandler(error) {
+    throw error;
+}
+function defaultMalformedUriErrorHandler(error, urlSerializer, url) {
+    return urlSerializer.parse('/');
+}
+/**
+ * The equivalent `IsActiveMatchOptions` options for `Router.isActive` is called with `true`
+ * (exact = true).
+ */
+const exactMatchOptions = {
+    paths: 'exact',
+    fragment: 'ignored',
+    matrixParams: 'ignored',
+    queryParams: 'exact'
+};
+/**
+ * The equivalent `IsActiveMatchOptions` options for `Router.isActive` is called with `false`
+ * (exact = false).
+ */
+const subsetMatchOptions = {
+    paths: 'subset',
+    fragment: 'ignored',
+    matrixParams: 'ignored',
+    queryParams: 'subset'
+};
+function assignExtraOptionsToRouter(opts, router) {
+    if (opts.errorHandler) {
+        router.errorHandler = opts.errorHandler;
+    }
+    if (opts.malformedUriErrorHandler) {
+        router.malformedUriErrorHandler = opts.malformedUriErrorHandler;
+    }
+    if (opts.onSameUrlNavigation) {
+        router.onSameUrlNavigation = opts.onSameUrlNavigation;
+    }
+    if (opts.paramsInheritanceStrategy) {
+        router.paramsInheritanceStrategy = opts.paramsInheritanceStrategy;
+    }
+    if (opts.urlUpdateStrategy) {
+        router.urlUpdateStrategy = opts.urlUpdateStrategy;
+    }
+    if (opts.canceledNavigationResolution) {
+        router.canceledNavigationResolution = opts.canceledNavigationResolution;
+    }
+}
 function setupRouter() {
     var _a, _b;
     const urlSerializer = inject(UrlSerializer);
@@ -4710,18 +5091,7 @@ function setupRouter() {
     const compiler = inject(Compiler);
     const config = (_a = inject(ROUTES, { optional: true })) !== null && _a !== void 0 ? _a : [];
     const opts = (_b = inject(ROUTER_CONFIGURATION, { optional: true })) !== null && _b !== void 0 ? _b : {};
-    const defaultTitleStrategy = inject(DefaultTitleStrategy);
-    const titleStrategy = inject(TitleStrategy, { optional: true });
-    const urlHandlingStrategy = inject(UrlHandlingStrategy, { optional: true });
-    const routeReuseStrategy = inject(RouteReuseStrategy, { optional: true });
     const router = new Router(null, urlSerializer, contexts, location, injector, compiler, flatten(config));
-    if (urlHandlingStrategy) {
-        router.urlHandlingStrategy = urlHandlingStrategy;
-    }
-    if (routeReuseStrategy) {
-        router.routeReuseStrategy = routeReuseStrategy;
-    }
-    router.titleStrategy = titleStrategy !== null && titleStrategy !== void 0 ? titleStrategy : defaultTitleStrategy;
     assignExtraOptionsToRouter(opts, router);
     return router;
 }
@@ -4742,16 +5112,15 @@ class Router {
      * Creates the router service.
      */
     // TODO: vsavkin make internal after the final is out.
-    constructor(rootComponentType, urlSerializer, rootContexts, location, injector, compiler, config) {
+    constructor(
+    /** @internal */
+    rootComponentType, urlSerializer, rootContexts, location, injector, compiler, config) {
         this.rootComponentType = rootComponentType;
         this.urlSerializer = urlSerializer;
         this.rootContexts = rootContexts;
         this.location = location;
         this.config = config;
-        this.lastSuccessfulNavigation = null;
-        this.currentNavigation = null;
         this.disposed = false;
-        this.navigationId = 0;
         /**
          * The id of the currently active page in the router.
          * Updated to the transition's target id on a successful navigation.
@@ -4762,10 +5131,6 @@ class Router {
          */
         this.currentPageId = 0;
         this.isNgZoneEnabled = false;
-        /**
-         * An event stream for routing events in this NgModule.
-         */
-        this.events = new Subject();
         /**
          * A handler for navigation errors in this NgModule.
          */
@@ -4794,11 +5159,15 @@ class Router {
          * A strategy for extracting and merging URLs.
          * Used for AngularJS to Angular migrations.
          */
-        this.urlHandlingStrategy = new DefaultUrlHandlingStrategy();
+        this.urlHandlingStrategy = inject(UrlHandlingStrategy);
         /**
          * A strategy for re-using routes.
          */
-        this.routeReuseStrategy = new DefaultRouteReuseStrategy();
+        this.routeReuseStrategy = inject(RouteReuseStrategy);
+        /**
+         * A strategy for setting the title based on the `routerState`.
+         */
+        this.titleStrategy = inject(TitleStrategy);
         /**
          * How to handle a navigation request to the current URL. One of:
          *
@@ -4849,48 +5218,31 @@ class Router {
          * Note: the 'computed' option is incompatible with any `UrlHandlingStrategy` which only
          * handles a portion of the URL because the history restoration navigates to the previous place in
          * the browser history rather than simply resetting a portion of the URL.
-         *
-         * The default value is `replace`.
-         *
-         */
-        this.canceledNavigationResolution = 'replace';
-        const onLoadStart = (r) => this.triggerEvent(new RouteConfigLoadStart(r));
-        const onLoadEnd = (r) => this.triggerEvent(new RouteConfigLoadEnd(r));
-        this.configLoader = injector.get(RouterConfigLoader);
-        this.configLoader.onLoadEndListener = onLoadEnd;
-        this.configLoader.onLoadStartListener = onLoadStart;
-        this.ngModule = injector.get(NgModuleRef);
-        this.console = injector.get(ɵConsole);
-        const ngZone = injector.get(NgZone);
-        this.isNgZoneEnabled = ngZone instanceof NgZone && NgZone.isInAngularZone();
-        this.resetConfig(config);
-        this.currentUrlTree = new UrlTree();
-        this.rawUrlTree = this.currentUrlTree;
-        this.browserUrlTree = this.currentUrlTree;
-        this.routerState = createEmptyState(this.currentUrlTree, this.rootComponentType);
-        this.transitions = new BehaviorSubject({
-            id: 0,
-            targetPageId: 0,
-            currentUrlTree: this.currentUrlTree,
-            currentRawUrl: this.currentUrlTree,
-            extractedUrl: this.urlHandlingStrategy.extract(this.currentUrlTree),
-            urlAfterRedirects: this.urlHandlingStrategy.extract(this.currentUrlTree),
-            rawUrl: this.currentUrlTree,
-            extras: {},
-            resolve: null,
-            reject: null,
-            promise: Promise.resolve(true),
-            source: 'imperative',
-            restoredState: null,
-            currentSnapshot: this.routerState.snapshot,
-            targetSnapshot: null,
-            currentRouterState: this.routerState,
-            targetRouterState: null,
-            guards: { canActivateChecks: [], canDeactivateChecks: [] },
-            guardsResult: null,
+         *
+         * The default value is `replace`.
+         *
+         */
+        this.canceledNavigationResolution = 'replace';
+        this.navigationTransitions = inject(NavigationTransitions);
+        this.console = injector.get(ɵConsole);
+        const ngZone = injector.get(NgZone);
+        this.isNgZoneEnabled = ngZone instanceof NgZone && NgZone.isInAngularZone();
+        this.resetConfig(config);
+        this.currentUrlTree = new UrlTree();
+        this.rawUrlTree = this.currentUrlTree;
+        this.browserUrlTree = this.currentUrlTree;
+        this.routerState = createEmptyState(this.currentUrlTree, this.rootComponentType);
+        this.navigationTransitions.setupNavigations(this).subscribe(t => {
+            this.lastSuccessfulId = t.id;
+            this.currentPageId = t.targetPageId;
+        }, e => {
+            this.console.warn(`Unhandled Navigation Error: ${e}`);
         });
-        this.navigations = this.setupNavigations(this.transitions);
-        this.processNavigations();
+    }
+    // TODO(b/260747083): This should not exist and navigationId should be private in
+    // `NavigationTransitions`
+    get navigationId() {
+        return this.navigationTransitions.navigationId;
     }
     /**
      * The ɵrouterPageId of whatever page is currently active in the browser history. This is
@@ -4901,281 +5253,15 @@ class Router {
         var _a;
         return (_a = this.location.getState()) === null || _a === void 0 ? void 0 : _a.ɵrouterPageId;
     }
-    setupNavigations(transitions) {
-        const eventsSubject = this.events;
-        return transitions.pipe(filter(t => t.id !== 0), 
-        // Extract URL
-        map(t => (Object.assign(Object.assign({}, t), { extractedUrl: this.urlHandlingStrategy.extract(t.rawUrl) }))), 
-        // Using switchMap so we cancel executing navigations when a new one comes in
-        switchMap(overallTransitionState => {
-            let completed = false;
-            let errored = false;
-            return of(overallTransitionState)
-                .pipe(
-            // Store the Navigation object
-            tap(t => {
-                this.currentNavigation = {
-                    id: t.id,
-                    initialUrl: t.rawUrl,
-                    extractedUrl: t.extractedUrl,
-                    trigger: t.source,
-                    extras: t.extras,
-                    previousNavigation: this.lastSuccessfulNavigation ? Object.assign(Object.assign({}, this.lastSuccessfulNavigation), { previousNavigation: null }) :
-                        null
-                };
-            }), switchMap(t => {
-                const browserUrlTree = this.browserUrlTree.toString();
-                const urlTransition = !this.navigated ||
-                    t.extractedUrl.toString() !== browserUrlTree ||
-                    // Navigations which succeed or ones which fail and are cleaned up
-                    // correctly should result in `browserUrlTree` and `currentUrlTree`
-                    // matching. If this is not the case, assume something went wrong and
-                    // try processing the URL again.
-                    browserUrlTree !== this.currentUrlTree.toString();
-                const processCurrentUrl = (this.onSameUrlNavigation === 'reload' ? true : urlTransition) &&
-                    this.urlHandlingStrategy.shouldProcessUrl(t.rawUrl);
-                if (processCurrentUrl) {
-                    // If the source of the navigation is from a browser event, the URL is
-                    // already updated. We already need to sync the internal state.
-                    if (isBrowserTriggeredNavigation(t.source)) {
-                        this.browserUrlTree = t.extractedUrl;
-                    }
-                    return of(t).pipe(
-                    // Fire NavigationStart event
-                    switchMap(t => {
-                        const transition = this.transitions.getValue();
-                        eventsSubject.next(new NavigationStart(t.id, this.serializeUrl(t.extractedUrl), t.source, t.restoredState));
-                        if (transition !== this.transitions.getValue()) {
-                            return EMPTY;
-                        }
-                        // This delay is required to match old behavior that forced
-                        // navigation to always be async
-                        return Promise.resolve(t);
-                    }), 
-                    // ApplyRedirects
-                    applyRedirects(this.ngModule.injector, this.configLoader, this.urlSerializer, this.config), 
-                    // Update the currentNavigation
-                    // `urlAfterRedirects` is guaranteed to be set after this point
-                    tap(t => {
-                        this.currentNavigation = Object.assign(Object.assign({}, this.currentNavigation), { finalUrl: t.urlAfterRedirects });
-                        overallTransitionState.urlAfterRedirects = t.urlAfterRedirects;
-                    }), 
-                    // Recognize
-                    recognize(this.ngModule.injector, this.rootComponentType, this.config, this.urlSerializer, this.paramsInheritanceStrategy), 
-                    // Update URL if in `eager` update mode
-                    tap(t => {
-                        overallTransitionState.targetSnapshot = t.targetSnapshot;
-                        if (this.urlUpdateStrategy === 'eager') {
-                            if (!t.extras.skipLocationChange) {
-                                const rawUrl = this.urlHandlingStrategy.merge(t.urlAfterRedirects, t.rawUrl);
-                                this.setBrowserUrl(rawUrl, t);
-                            }
-                            this.browserUrlTree = t.urlAfterRedirects;
-                        }
-                        // Fire RoutesRecognized
-                        const routesRecognized = new RoutesRecognized(t.id, this.serializeUrl(t.extractedUrl), this.serializeUrl(t.urlAfterRedirects), t.targetSnapshot);
-                        eventsSubject.next(routesRecognized);
-                    }));
-                }
-                else {
-                    const processPreviousUrl = urlTransition && this.rawUrlTree &&
-                        this.urlHandlingStrategy.shouldProcessUrl(this.rawUrlTree);
-                    /* When the current URL shouldn't be processed, but the previous one
-                     * was, we handle this "error condition" by navigating to the
-                     * previously successful URL, but leaving the URL intact.*/
-                    if (processPreviousUrl) {
-                        const { id, extractedUrl, source, restoredState, extras } = t;
-                        const navStart = new NavigationStart(id, this.serializeUrl(extractedUrl), source, restoredState);
-                        eventsSubject.next(navStart);
-                        const targetSnapshot = createEmptyState(extractedUrl, this.rootComponentType).snapshot;
-                        overallTransitionState = Object.assign(Object.assign({}, t), { targetSnapshot, urlAfterRedirects: extractedUrl, extras: Object.assign(Object.assign({}, extras), { skipLocationChange: false, replaceUrl: false }) });
-                        return of(overallTransitionState);
-                    }
-                    else {
-                        /* When neither the current or previous URL can be processed, do
-                         * nothing other than update router's internal reference to the
-                         * current "settled" URL. This way the next navigation will be coming
-                         * from the current URL in the browser.
-                         */
-                        this.rawUrlTree = t.rawUrl;
-                        t.resolve(null);
-                        return EMPTY;
-                    }
-                }
-            }), 
-            // --- GUARDS ---
-            tap(t => {
-                const guardsStart = new GuardsCheckStart(t.id, this.serializeUrl(t.extractedUrl), this.serializeUrl(t.urlAfterRedirects), t.targetSnapshot);
-                this.triggerEvent(guardsStart);
-            }), map(t => {
-                overallTransitionState = Object.assign(Object.assign({}, t), { guards: getAllRouteGuards(t.targetSnapshot, t.currentSnapshot, this.rootContexts) });
-                return overallTransitionState;
-            }), checkGuards(this.ngModule.injector, (evt) => this.triggerEvent(evt)), tap(t => {
-                overallTransitionState.guardsResult = t.guardsResult;
-                if (isUrlTree(t.guardsResult)) {
-                    throw redirectingNavigationError(this.urlSerializer, t.guardsResult);
-                }
-                const guardsEnd = new GuardsCheckEnd(t.id, this.serializeUrl(t.extractedUrl), this.serializeUrl(t.urlAfterRedirects), t.targetSnapshot, !!t.guardsResult);
-                this.triggerEvent(guardsEnd);
-            }), filter(t => {
-                if (!t.guardsResult) {
-                    this.restoreHistory(t);
-                    this.cancelNavigationTransition(t, '', 3 /* NavigationCancellationCode.GuardRejected */);
-                    return false;
-                }
-                return true;
-            }), 
-            // --- RESOLVE ---
-            switchTap(t => {
-                if (t.guards.canActivateChecks.length) {
-                    return of(t).pipe(tap(t => {
-                        const resolveStart = new ResolveStart(t.id, this.serializeUrl(t.extractedUrl), this.serializeUrl(t.urlAfterRedirects), t.targetSnapshot);
-                        this.triggerEvent(resolveStart);
-                    }), switchMap(t => {
-                        let dataResolved = false;
-                        return of(t).pipe(resolveData(this.paramsInheritanceStrategy, this.ngModule.injector), tap({
-                            next: () => dataResolved = true,
-                            complete: () => {
-                                if (!dataResolved) {
-                                    this.restoreHistory(t);
-                                    this.cancelNavigationTransition(t, NG_DEV_MODE$2 ?
-                                        `At least one route resolver didn't emit any value.` :
-                                        '', 2 /* NavigationCancellationCode.NoDataFromResolver */);
-                                }
-                            }
-                        }));
-                    }), tap(t => {
-                        const resolveEnd = new ResolveEnd(t.id, this.serializeUrl(t.extractedUrl), this.serializeUrl(t.urlAfterRedirects), t.targetSnapshot);
-                        this.triggerEvent(resolveEnd);
-                    }));
-                }
-                return undefined;
-            }), 
-            // --- LOAD COMPONENTS ---
-            switchTap((t) => {
-                const loadComponents = (route) => {
-                    var _a;
-                    const loaders = [];
-                    if (((_a = route.routeConfig) === null || _a === void 0 ? void 0 : _a.loadComponent) &&
-                        !route.routeConfig._loadedComponent) {
-                        loaders.push(this.configLoader.loadComponent(route.routeConfig)
-                            .pipe(tap(loadedComponent => {
-                            route.component = loadedComponent;
-                        }), map(() => void 0)));
-                    }
-                    for (const child of route.children) {
-                        loaders.push(...loadComponents(child));
-                    }
-                    return loaders;
-                };
-                return combineLatest(loadComponents(t.targetSnapshot.root))
-                    .pipe(defaultIfEmpty(), take(1));
-            }), switchTap(() => this.afterPreactivation()), map((t) => {
-                const targetRouterState = createRouterState(this.routeReuseStrategy, t.targetSnapshot, t.currentRouterState);
-                overallTransitionState = Object.assign(Object.assign({}, t), { targetRouterState });
-                return (overallTransitionState);
-            }), 
-            /* Once here, we are about to activate synchronously. The assumption is
-               this will succeed, and user code may read from the Router service.
-               Therefore before activation, we need to update router properties storing
-               the current URL and the RouterState, as well as updated the browser URL.
-               All this should happen *before* activating. */
-            tap((t) => {
-                this.currentUrlTree = t.urlAfterRedirects;
-                this.rawUrlTree =
-                    this.urlHandlingStrategy.merge(t.urlAfterRedirects, t.rawUrl);
-                this.routerState = t.targetRouterState;
-                if (this.urlUpdateStrategy === 'deferred') {
-                    if (!t.extras.skipLocationChange) {
-                        this.setBrowserUrl(this.rawUrlTree, t);
-                    }
-                    this.browserUrlTree = t.urlAfterRedirects;
-                }
-            }), activateRoutes(this.rootContexts, this.routeReuseStrategy, (evt) => this.triggerEvent(evt)), tap({
-                next() {
-                    completed = true;
-                },
-                complete() {
-                    completed = true;
-                }
-            }), finalize(() => {
-                var _a;
-                /* When the navigation stream finishes either through error or success,
-                 * we set the `completed` or `errored` flag. However, there are some
-                 * situations where we could get here without either of those being set.
-                 * For instance, a redirect during NavigationStart. Therefore, this is a
-                 * 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$2 ?
-                        `Navigation ID ${overallTransitionState
-                            .id} is not equal to the current navigation id ${this.navigationId}` :
-                        '';
-                    this.cancelNavigationTransition(overallTransitionState, cancelationReason, 1 /* NavigationCancellationCode.SupersededByNewNavigation */);
-                }
-                // Only clear current navigation if it is still set to the one that
-                // finalized.
-                if (((_a = this.currentNavigation) === null || _a === void 0 ? void 0 : _a.id) === overallTransitionState.id) {
-                    this.currentNavigation = null;
-                }
-            }), catchError((e) => {
-                var _a;
-                errored = true;
-                /* This error type is issued during Redirect, and is handled as a
-                 * cancellation rather than an error. */
-                if (isNavigationCancelingError$1(e)) {
-                    if (!isRedirectingNavigationCancelingError$1(e)) {
-                        // Set property only if we're not redirecting. If we landed on a page
-                        // and redirect to `/` route, the new navigation is going to see the
-                        // `/` isn't a change from the default currentUrlTree and won't
-                        // navigate. This is only applicable with initial navigation, so
-                        // setting `navigated` only when not redirecting resolves this
-                        // scenario.
-                        this.navigated = true;
-                        this.restoreHistory(overallTransitionState, true);
-                    }
-                    const navCancel = new NavigationCancel(overallTransitionState.id, this.serializeUrl(overallTransitionState.extractedUrl), e.message, e.cancellationCode);
-                    eventsSubject.next(navCancel);
-                    // When redirecting, we need to delay resolving the navigation
-                    // promise and push it to the redirect navigation
-                    if (!isRedirectingNavigationCancelingError$1(e)) {
-                        overallTransitionState.resolve(false);
-                    }
-                    else {
-                        const mergedTree = this.urlHandlingStrategy.merge(e.url, this.rawUrlTree);
-                        const extras = {
-                            skipLocationChange: overallTransitionState.extras.skipLocationChange,
-                            // The URL is already updated at this point if we have 'eager' URL
-                            // updates or if the navigation was triggered by the browser (back
-                            // button, URL bar, etc). We want to replace that item in history
-                            // if the navigation is rejected.
-                            replaceUrl: this.urlUpdateStrategy === 'eager' ||
-                                isBrowserTriggeredNavigation(overallTransitionState.source)
-                        };
-                        this.scheduleNavigation(mergedTree, 'imperative', null, extras, {
-                            resolve: overallTransitionState.resolve,
-                            reject: overallTransitionState.reject,
-                            promise: overallTransitionState.promise
-                        });
-                    }
-                    /* All other errors should reset to the router's internal URL reference
-                     * to the pre-error state. */
-                }
-                else {
-                    this.restoreHistory(overallTransitionState, true);
-                    const navError = new NavigationError(overallTransitionState.id, this.serializeUrl(overallTransitionState.extractedUrl), e, (_a = overallTransitionState.targetSnapshot) !== null && _a !== void 0 ? _a : undefined);
-                    eventsSubject.next(navError);
-                    try {
-                        overallTransitionState.resolve(this.errorHandler(e));
-                    }
-                    catch (ee) {
-                        overallTransitionState.reject(ee);
-                    }
-                }
-                return EMPTY;
-            }));
-            // TODO(jasonaden): remove cast once g3 is on updated TypeScript
-        }));
+    /**
+     * An event stream for routing events.
+     */
+    get events() {
+        // TODO(atscott): This _should_ be events.asObservable(). However, this change requires internal
+        // cleanup: tests are doing `(route.events as Subject<Event>).next(...)`. This isn't
+        // allowed/supported but we still have to fix these or file bugs against the teams before making
+        // the change.
+        return this.navigationTransitions.events;
     }
     /**
      * @internal
@@ -5187,15 +5273,12 @@ class Router {
         // this will simplify the lifecycle of the router.
         this.routerState.root.component = this.rootComponentType;
     }
-    setTransition(t) {
-        this.transitions.next(Object.assign(Object.assign({}, this.transitions.value), t));
-    }
     /**
      * Sets up the location change listener and performs the initial navigation.
      */
     initialNavigation() {
         this.setUpLocationChangeListener();
-        if (this.navigationId === 0) {
+        if (!this.navigationTransitions.hasRequestedNavigation) {
             this.navigateByUrl(this.location.path(true), { replaceUrl: true });
         }
     }
@@ -5217,11 +5300,18 @@ class Router {
                     setTimeout(() => {
                         var _a;
                         const extras = { replaceUrl: true };
-                        // Navigations coming from Angular router have a navigationId state
-                        // property. When this exists, restore the state.
-                        const state = ((_a = event.state) === null || _a === void 0 ? void 0 : _a.navigationId) ? event.state : null;
-                        if (state) {
-                            const stateCopy = Object.assign({}, state);
+                        // TODO: restoredState should always include the entire state, regardless
+                        // of navigationId. This requires a breaking change to update the type on
+                        // NavigationStart’s restoredState, which currently requires navigationId
+                        // to always be present. The Router used to only restore history state if
+                        // a navigationId was present.
+                        // The stored navigationId is used by the RouterScroller to retrieve the scroll
+                        // position for the page.
+                        const restoredState = ((_a = event.state) === null || _a === void 0 ? void 0 : _a.navigationId) ? event.state : null;
+                        // Separate to NavigationStart.restoredState, we must also restore the state to
+                        // history.state and generate a new navigationId, since it will be overwritten
+                        if (event.state) {
+                            const stateCopy = Object.assign({}, event.state);
                             delete stateCopy.navigationId;
                             delete stateCopy.ɵrouterPageId;
                             if (Object.keys(stateCopy).length !== 0) {
@@ -5229,7 +5319,7 @@ class Router {
                             }
                         }
                         const urlTree = this.parseUrl(event['url']);
-                        this.scheduleNavigation(urlTree, source, state, extras);
+                        this.scheduleNavigation(urlTree, source, restoredState, extras);
                     }, 0);
                 }
             });
@@ -5244,11 +5334,7 @@ class Router {
      * and `null` when idle.
      */
     getCurrentNavigation() {
-        return this.currentNavigation;
-    }
-    /** @internal */
-    triggerEvent(event) {
-        this.events.next(event);
+        return this.navigationTransitions.currentNavigation;
     }
     /**
      * Resets the route configuration used for navigation and generating links.
@@ -5278,7 +5364,7 @@ class Router {
     }
     /** Disposes of the router. */
     dispose() {
-        this.transitions.complete();
+        this.navigationTransitions.complete();
         if (this.locationSubscription) {
             this.locationSubscription.unsubscribe();
             this.locationSubscription = undefined;
@@ -5463,21 +5549,7 @@ class Router {
             return result;
         }, {});
     }
-    processNavigations() {
-        this.navigations.subscribe(t => {
-            var _a;
-            this.navigated = true;
-            this.lastSuccessfulId = t.id;
-            this.currentPageId = t.targetPageId;
-            this.events
-                .next(new NavigationEnd(t.id, this.serializeUrl(t.extractedUrl), this.serializeUrl(this.currentUrlTree)));
-            this.lastSuccessfulNavigation = this.currentNavigation;
-            (_a = this.titleStrategy) === null || _a === void 0 ? void 0 : _a.updateTitle(this.routerState.snapshot);
-            t.resolve(true);
-        }, e => {
-            this.console.warn(`Unhandled Navigation Error: ${e}`);
-        });
-    }
+    /** @internal */
     scheduleNavigation(rawUrl, source, restoredState, extras, priorPromise) {
         var _a, _b;
         if (this.disposed) {
@@ -5497,7 +5569,6 @@ class Router {
                 reject = rej;
             });
         }
-        const id = ++this.navigationId;
         let targetPageId;
         if (this.canceledNavigationResolution === 'computed') {
             const isInitialPage = this.currentPageId === 0;
@@ -5525,13 +5596,12 @@ class Router {
             // This is unused when `canceledNavigationResolution` is not computed.
             targetPageId = 0;
         }
-        this.setTransition({
-            id,
+        this.navigationTransitions.handleNavigationRequest({
             targetPageId,
             source,
             restoredState,
             currentUrlTree: this.currentUrlTree,
-            currentRawUrl: this.rawUrlTree,
+            currentRawUrl: this.currentUrlTree,
             rawUrl,
             extras,
             resolve,
@@ -5546,10 +5616,11 @@ class Router {
             return Promise.reject(e);
         });
     }
-    setBrowserUrl(url, t) {
+    /** @internal */
+    setBrowserUrl(url, transition) {
         const path = this.urlSerializer.serialize(url);
-        const state = Object.assign(Object.assign({}, t.extras.state), this.generateNgRouterState(t.id, t.targetPageId));
-        if (this.location.isCurrentPathEqualTo(path) || !!t.extras.replaceUrl) {
+        const state = Object.assign(Object.assign({}, transition.extras.state), this.generateNgRouterState(transition.id, transition.targetPageId));
+        if (this.location.isCurrentPathEqualTo(path) || !!transition.extras.replaceUrl) {
             this.location.replaceState(path, '', state);
         }
         else {
@@ -5559,29 +5630,31 @@ class Router {
     /**
      * Performs the necessary rollback action to restore the browser URL to the
      * state before the transition.
+     * @internal
      */
-    restoreHistory(t, restoringFromCaughtError = false) {
+    restoreHistory(transition, restoringFromCaughtError = false) {
         var _a, _b;
         if (this.canceledNavigationResolution === 'computed') {
-            const targetPagePosition = this.currentPageId - t.targetPageId;
+            const targetPagePosition = this.currentPageId - transition.targetPageId;
             // The navigator change the location before triggered the browser event,
             // so we need to go back to the current url if the navigation is canceled.
             // Also, when navigation gets cancelled while using url update strategy eager, then we need to
             // go back. Because, when `urlUpdateStrategy` is `eager`; `setBrowserUrl` method is called
             // before any verification.
-            const browserUrlUpdateOccurred = (t.source === 'popstate' || this.urlUpdateStrategy === 'eager' ||
-                this.currentUrlTree === ((_a = this.currentNavigation) === null || _a === void 0 ? void 0 : _a.finalUrl));
+            const browserUrlUpdateOccurred = (transition.source === 'popstate' || this.urlUpdateStrategy === 'eager' ||
+                this.currentUrlTree === ((_a = this.getCurrentNavigation()) === null || _a === void 0 ? void 0 : _a.finalUrl));
             if (browserUrlUpdateOccurred && targetPagePosition !== 0) {
                 this.location.historyGo(targetPagePosition);
             }
-            else if (this.currentUrlTree === ((_b = this.currentNavigation) === null || _b === void 0 ? void 0 : _b.finalUrl) && targetPagePosition === 0) {
+            else if (this.currentUrlTree === ((_b = this.getCurrentNavigation()) === null || _b === void 0 ? void 0 : _b.finalUrl) &&
+                targetPagePosition === 0) {
                 // We got to the activation stage (where currentUrlTree is set to the navigation's
                 // finalUrl), but we weren't moving anywhere in history (skipLocationChange or replaceUrl).
                 // We still need to reset the router state back to what it was when the navigation started.
-                this.resetState(t);
+                this.resetState(transition);
                 // TODO(atscott): resetting the `browserUrlTree` should really be done in `resetState`.
                 // Investigate if this can be done by running TGP.
-                this.browserUrlTree = t.currentUrlTree;
+                this.browserUrlTree = transition.currentUrlTree;
                 this.resetUrlToCurrentUrlTree();
             }
             else {
@@ -5595,7 +5668,7 @@ class Router {
             // reject. For 'eager' navigations, it seems like we also really should reset the state
             // because the navigation was cancelled. Investigate if this can be done by running TGP.
             if (restoringFromCaughtError) {
-                this.resetState(t);
+                this.resetState(transition);
             }
             this.resetUrlToCurrentUrlTree();
         }
@@ -5613,11 +5686,6 @@ class Router {
     resetUrlToCurrentUrlTree() {
         this.location.replaceState(this.urlSerializer.serialize(this.rawUrlTree), '', this.generateNgRouterState(this.lastSuccessfulId, this.currentPageId));
     }
-    cancelNavigationTransition(t, reason, code) {
-        const navCancel = new NavigationCancel(t.id, this.serializeUrl(t.extractedUrl), reason, code);
-        this.triggerEvent(navCancel);
-        t.resolve(false);
-    }
     generateNgRouterState(navigationId, routerPageId) {
         if (this.canceledNavigationResolution === 'computed') {
             return { navigationId, ɵrouterPageId: routerPageId };
@@ -5625,9 +5693,9 @@ class Router {
         return { navigationId };
     }
 }
-Router.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: Router, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
-Router.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: Router, providedIn: 'root', useFactory: setupRouter });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: Router, decorators: [{
+Router.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: Router, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+Router.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: Router, providedIn: 'root', useFactory: setupRouter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: Router, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -5642,9 +5710,6 @@ function validateCommands(commands) {
         }
     }
 }
-function isBrowserTriggeredNavigation(source) {
-    return source !== 'imperative';
-}
 
 /**
  * @description
@@ -5921,9 +5986,9 @@ class RouterLink {
         });
     }
 }
-RouterLink.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", 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: "15.0.0", 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: "15.0.0", ngImport: i0, type: RouterLink, decorators: [{
+RouterLink.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", 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: "15.0.2", 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: "15.0.2", ngImport: i0, type: RouterLink, decorators: [{
             type: Directive,
             args: [{
                     selector: '[routerLink]',
@@ -6152,9 +6217,9 @@ class RouterLinkActive {
         return this.link && isActiveCheckFn(this.link) || this.links.some(isActiveCheckFn);
     }
 }
-RouterLinkActive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", 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: "15.0.0", 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: "15.0.0", ngImport: i0, type: RouterLinkActive, decorators: [{
+RouterLinkActive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", 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: "15.0.2", 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: "15.0.2", ngImport: i0, type: RouterLinkActive, decorators: [{
             type: Directive,
             args: [{
                     selector: '[routerLinkActive]',
@@ -6216,9 +6281,9 @@ class PreloadAllModules {
         return fn().pipe(catchError(() => of(null)));
     }
 }
-PreloadAllModules.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: PreloadAllModules, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-PreloadAllModules.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: PreloadAllModules, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: PreloadAllModules, decorators: [{
+PreloadAllModules.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: PreloadAllModules, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PreloadAllModules.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: PreloadAllModules, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: PreloadAllModules, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -6236,9 +6301,9 @@ class NoPreloading {
         return of(null);
     }
 }
-NoPreloading.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NoPreloading, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-NoPreloading.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NoPreloading, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NoPreloading, decorators: [{
+NoPreloading.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: NoPreloading, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NoPreloading.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: NoPreloading, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: NoPreloading, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -6334,18 +6399,19 @@ class RouterPreloader {
         });
     }
 }
-RouterPreloader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", 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: "15.0.0", ngImport: i0, type: RouterPreloader, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: RouterPreloader, decorators: [{
+RouterPreloader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", 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: "15.0.2", ngImport: i0, type: RouterPreloader, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", 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 }]; } });
 
 const ROUTER_SCROLLER = new InjectionToken('');
 class RouterScroller {
-    constructor(router, 
-    /** @docsNotRequired */ viewportScroller, zone, options = {}) {
-        this.router = router;
+    /** @nodoc */
+    constructor(urlSerializer, transitions, viewportScroller, zone, options = {}) {
+        this.urlSerializer = urlSerializer;
+        this.transitions = transitions;
         this.viewportScroller = viewportScroller;
         this.zone = zone;
         this.options = options;
@@ -6368,7 +6434,7 @@ class RouterScroller {
         this.scrollEventsSubscription = this.consumeScrollEvents();
     }
     createScrollEvents() {
-        return this.router.events.subscribe(e => {
+        return this.transitions.events.subscribe(e => {
             if (e instanceof NavigationStart) {
                 // store the scroll position of the current stable navigations.
                 this.store[this.lastId] = this.viewportScroller.getScrollPosition();
@@ -6377,12 +6443,12 @@ class RouterScroller {
             }
             else if (e instanceof NavigationEnd) {
                 this.lastId = e.id;
-                this.scheduleScrollEvent(e, this.router.parseUrl(e.urlAfterRedirects).fragment);
+                this.scheduleScrollEvent(e, this.urlSerializer.parse(e.urlAfterRedirects).fragment);
             }
         });
     }
     consumeScrollEvents() {
-        return this.router.events.subscribe(e => {
+        return this.transitions.events.subscribe(e => {
             if (!(e instanceof Scroll))
                 return;
             // a popstate event. The pop state event will always ignore anchor scrolling.
@@ -6412,26 +6478,23 @@ class RouterScroller {
             // component by executing its update block of the template function.
             setTimeout(() => {
                 this.zone.run(() => {
-                    this.router.triggerEvent(new Scroll(routerEvent, this.lastSource === 'popstate' ? this.store[this.restoredId] : null, anchor));
+                    this.transitions.events.next(new Scroll(routerEvent, this.lastSource === 'popstate' ? this.store[this.restoredId] : null, anchor));
                 });
             }, 0);
         });
     }
     /** @nodoc */
     ngOnDestroy() {
-        if (this.routerEventsSubscription) {
-            this.routerEventsSubscription.unsubscribe();
-        }
-        if (this.scrollEventsSubscription) {
-            this.scrollEventsSubscription.unsubscribe();
-        }
+        var _a, _b;
+        (_a = this.routerEventsSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        (_b = this.scrollEventsSubscription) === null || _b === void 0 ? void 0 : _b.unsubscribe();
     }
 }
-RouterScroller.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
-RouterScroller.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: RouterScroller });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: RouterScroller, decorators: [{
+RouterScroller.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+RouterScroller.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouterScroller });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouterScroller, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: Router }, { type: i3.ViewportScroller }, { type: i0.NgZone }, { type: undefined }]; } });
+        }], ctorParameters: function () { return [{ type: UrlSerializer }, { type: NavigationTransitions }, { type: i3.ViewportScroller }, { type: i0.NgZone }, { type: undefined }]; } });
 
 /**
  * @license
@@ -6568,10 +6631,11 @@ function withInMemoryScrolling(options = {}) {
     const providers = [{
             provide: ROUTER_SCROLLER,
             useFactory: () => {
-                const router = inject(Router);
                 const viewportScroller = inject(ViewportScroller);
                 const zone = inject(NgZone);
-                return new RouterScroller(router, viewportScroller, zone, options);
+                const transitions = inject(NavigationTransitions);
+                const urlSerializer = inject(UrlSerializer);
+                return new RouterScroller(urlSerializer, transitions, viewportScroller, zone, options);
             },
         }];
     return routerFeature(4 /* RouterFeatureKind.InMemoryScrollingFeature */, providers);
@@ -6592,8 +6656,10 @@ function getBootstrapListener() {
         (_a = injector.get(ROUTER_PRELOADER, null, InjectFlags.Optional)) === null || _a === void 0 ? void 0 : _a.setUpPreloading();
         (_b = injector.get(ROUTER_SCROLLER, null, InjectFlags.Optional)) === null || _b === void 0 ? void 0 : _b.init();
         router.resetRootComponentType(ref.componentTypes[0]);
-        bootstrapDone.next();
-        bootstrapDone.complete();
+        if (!bootstrapDone.closed) {
+            bootstrapDone.next();
+            bootstrapDone.unsubscribe();
+        }
     };
 }
 /**
@@ -6641,7 +6707,6 @@ function withEnabledBlockingInitialNavigation() {
             deps: [Injector],
             useFactory: (injector) => {
                 const locationInitialized = injector.get(LOCATION_INITIALIZED, Promise.resolve());
-                let initNavigation = false;
                 /**
                  * Performs the given action once the router finishes its next/current navigation.
                  *
@@ -6676,21 +6741,13 @@ function withEnabledBlockingInitialNavigation() {
                                 // Unblock APP_INITIALIZER in case the initial navigation was canceled or errored
                                 // without a redirect.
                                 resolve(true);
-                                initNavigation = true;
                             });
                             router.afterPreactivation = () => {
                                 // Unblock APP_INITIALIZER once we get to `afterPreactivation`. At this point, we
                                 // assume activation will complete successfully (even though this is not
                                 // guaranteed).
                                 resolve(true);
-                                // only the initial navigation should be delayed until bootstrapping is done.
-                                if (!initNavigation) {
-                                    return bootstrapDone.closed ? of(void 0) : bootstrapDone;
-                                    // subsequent navigations should not be delayed
-                                }
-                                else {
-                                    return of(void 0);
-                                }
+                                return bootstrapDone.closed ? of(void 0) : bootstrapDone;
                             };
                             router.initialNavigation();
                         });
@@ -6980,10 +7037,10 @@ class RouterModule {
         };
     }
 }
-RouterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: RouterModule, deps: [{ token: ROUTER_FORROOT_GUARD, optional: true }], target: i0.ɵɵFactoryTarget.NgModule });
-RouterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.0", ngImport: i0, type: RouterModule, imports: [RouterOutlet, RouterLink, RouterLinkActive, ɵEmptyOutletComponent], exports: [RouterOutlet, RouterLink, RouterLinkActive, ɵEmptyOutletComponent] });
-RouterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: RouterModule, imports: [ɵEmptyOutletComponent] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: RouterModule, decorators: [{
+RouterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouterModule, deps: [{ token: ROUTER_FORROOT_GUARD, optional: true }], target: i0.ɵɵFactoryTarget.NgModule });
+RouterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: RouterModule, imports: [RouterOutlet, RouterLink, RouterLinkActive, ɵEmptyOutletComponent], exports: [RouterOutlet, RouterLink, RouterLinkActive, ɵEmptyOutletComponent] });
+RouterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouterModule, imports: [ɵEmptyOutletComponent] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RouterModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: ROUTER_DIRECTIVES,
@@ -7005,14 +7062,15 @@ function provideRouterScroller() {
     return {
         provide: ROUTER_SCROLLER,
         useFactory: () => {
-            const router = inject(Router);
             const viewportScroller = inject(ViewportScroller);
             const zone = inject(NgZone);
             const config = inject(ROUTER_CONFIGURATION);
+            const transitions = inject(NavigationTransitions);
+            const urlSerializer = inject(UrlSerializer);
             if (config.scrollOffset) {
                 viewportScroller.setOffset(config.scrollOffset);
             }
-            return new RouterScroller(router, viewportScroller, zone, config);
+            return new RouterScroller(urlSerializer, transitions, viewportScroller, zone, config);
         },
     };
 }
@@ -7070,7 +7128,7 @@ function provideRouterInitializer() {
 /**
  * @publicApi
  */
-const VERSION = new Version('15.0.0');
+const VERSION = new Version('15.0.2');
 
 /**
  * @license