@angular/router 14.1.0-next.3 → 14.1.0

package/fesm2015/router.mjs

@@ -1,13 +1,13 @@
 /**
- * @license Angular v14.1.0-next.3
+ * @license Angular v14.1.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
 
 import * as i0 from '@angular/core';
-import { ɵisObservable, ɵisPromise, EventEmitter, Directive, Attribute, Output, Component, createEnvironmentInjector, ɵisStandalone, ComponentFactoryResolver, InjectionToken, InjectFlags, NgModuleFactory, Injectable, NgModuleRef, ɵConsole, NgZone, ɵcoerceToBoolean, Input, HostListener, HostBinding, Optional, ContentChildren, Injector, Compiler, NgProbeToken, ANALYZE_FOR_ENTRY_COMPONENTS, SkipSelf, inject, APP_INITIALIZER, APP_BOOTSTRAP_LISTENER, NgModule, Inject, ApplicationRef, ENVIRONMENT_INITIALIZER, Version } from '@angular/core';
+import { ɵisObservable, ɵisPromise, ɵRuntimeError, EventEmitter, Directive, Attribute, Output, Component, createEnvironmentInjector, ɵisStandalone, ComponentFactoryResolver, InjectionToken, InjectFlags, NgModuleFactory, Injectable, NgModuleRef, ɵConsole, NgZone, ɵcoerceToBoolean, Input, HostListener, HostBinding, Optional, ContentChildren, inject, Injector, Compiler, NgProbeToken, ANALYZE_FOR_ENTRY_COMPONENTS, SkipSelf, APP_INITIALIZER, APP_BOOTSTRAP_LISTENER, NgModule, Inject, ApplicationRef, ENVIRONMENT_INITIALIZER, Version } from '@angular/core';
 import { from, of, BehaviorSubject, combineLatest, concat, defer, pipe, throwError, EmptyError, Observable, EMPTY, ConnectableObservable, Subject } from 'rxjs';
-import { map, switchMap, take, startWith, scan, filter, mergeMap, first, concatMap, tap, catchError, last as last$1, takeWhile, defaultIfEmpty, takeLast, mapTo, finalize, refCount, mergeAll } from 'rxjs/operators';
+import { map, switchMap, take, startWith, filter, mergeMap, first, concatMap, tap, catchError, scan, last as last$1, takeWhile, defaultIfEmpty, takeLast, mapTo, finalize, refCount, mergeAll } from 'rxjs/operators';
 import * as i3 from '@angular/common';
 import { Location, LocationStrategy, HashLocationStrategy, PathLocationStrategy, ViewportScroller, LOCATION_INITIALIZED } from '@angular/common';
 import * as i1 from '@angular/platform-browser';
@@ -60,15 +60,6 @@ class ParamsAsMap {
 function convertToParamMap(params) {
     return new ParamsAsMap(params);
 }
-const NAVIGATION_CANCELING_ERROR = 'ngNavigationCancelingError';
-function navigationCancelingError(message) {
-    const error = Error('NavigationCancelingError: ' + message);
-    error[NAVIGATION_CANCELING_ERROR] = true;
-    return error;
-}
-function isNavigationCancelingError(error) {
-    return error && error[NAVIGATION_CANCELING_ERROR];
-}
 // Matches the route configuration (`route`) against the actual URL (`segments`).
 function defaultUrlMatcher(segments, segmentGroup, route) {
     const parts = route.path.split('/');
@@ -191,6 +182,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$7 = typeof ngDevMode === 'undefined' || ngDevMode;
 function createEmptyUrlTree() {
     return new UrlTree(new UrlSegmentGroup([], {}), {}, null);
 }
@@ -655,7 +647,7 @@ class UrlParser {
     parseSegment() {
         const path = matchSegments(this.remaining);
         if (path === '' && this.peekStartsWith(';')) {
-            throw new Error(`Empty path url segment cannot have parameters: '${this.remaining}'.`);
+            throw new ɵRuntimeError(4009 /* RuntimeErrorCode.EMPTY_PATH_WITH_PARAMS */, NG_DEV_MODE$7 && `Empty path url segment cannot have parameters: '${this.remaining}'.`);
         }
         this.capture(path);
         return new UrlSegment(decode(path), this.parseMatrixParams());
@@ -724,7 +716,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 Error(`Cannot parse url '${this.url}'`);
+                throw new ɵRuntimeError(4010 /* RuntimeErrorCode.UNPARSABLE_URL */, NG_DEV_MODE$7 && `Cannot parse url '${this.url}'`);
             }
             let outletName = undefined;
             if (path.indexOf(':') > -1) {
@@ -755,7 +747,7 @@ class UrlParser {
     }
     capture(str) {
         if (!this.consumeOptional(str)) {
-            throw new Error(`Expected "${str}".`);
+            throw new ɵRuntimeError(4011 /* RuntimeErrorCode.UNEXPECTED_VALUE_IN_URL */, NG_DEV_MODE$7 && `Expected "${str}".`);
         }
     }
 }
@@ -797,6 +789,9 @@ function mergeTrivialChildren(s) {
     }
     return s;
 }
+function isUrlTree(v) {
+    return v instanceof UrlTree;
+}
 
 /**
  * @license
@@ -805,6 +800,7 @@ function mergeTrivialChildren(s) {
  * 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;
 /**
  * Creates a `UrlTree` relative to an `ActivatedRouteSnapshot`.
  *
@@ -982,11 +978,11 @@ class Navigation {
         this.numberOfDoubleDots = numberOfDoubleDots;
         this.commands = commands;
         if (isAbsolute && commands.length > 0 && isMatrixParams(commands[0])) {
-            throw new Error('Root segment cannot have matrix parameters');
+            throw new ɵRuntimeError(4003 /* RuntimeErrorCode.ROOT_SEGMENT_MATRIX_PARAMS */, NG_DEV_MODE$6 && 'Root segment cannot have matrix parameters');
         }
         const cmdWithOutlet = commands.find(isCommandWithOutlets);
         if (cmdWithOutlet && cmdWithOutlet !== last(commands)) {
-            throw new Error('{outlets:{}} has to be the last command');
+            throw new ɵRuntimeError(4004 /* RuntimeErrorCode.MISPLACED_OUTLETS_COMMAND */, NG_DEV_MODE$6 && '{outlets:{}} has to be the last command');
         }
     }
     toRoot() {
@@ -1085,7 +1081,7 @@ function createPositionApplyingDoubleDots(group, index, numberOfDoubleDots) {
         dd -= ci;
         g = g.parent;
         if (!g) {
-            throw new Error('Invalid number of \'../\'');
+            throw new ɵRuntimeError(4005 /* RuntimeErrorCode.INVALID_DOUBLE_DOTS */, NG_DEV_MODE$6 && 'Invalid number of \'../\'');
         }
         ci = g.segments.length;
     }
@@ -1340,10 +1336,20 @@ class NavigationCancel extends RouterEvent {
     id, 
     /** @docsNotRequired */
     url, 
-    /** @docsNotRequired */
-    reason) {
+    /**
+     * A description of why the navigation was cancelled. For debug purposes only. Use `code`
+     * instead for a stable cancellation reason that can be used in production.
+     */
+    reason, 
+    /**
+     * A code to indicate why the navigation was canceled. This cancellation code is stable for
+     * the reason and can be relied on whereas the `reason` string could change and should not be
+     * used in production.
+     */
+    code) {
         super(id, url);
         this.reason = reason;
+        this.code = code;
         this.type = 2 /* EventType.NavigationCancel */;
     }
     /** @docsNotRequired */
@@ -1367,9 +1373,17 @@ class NavigationError extends RouterEvent {
     /** @docsNotRequired */
     url, 
     /** @docsNotRequired */
-    error) {
+    error, 
+    /**
+     * The target of the navigation when the error occurred.
+     *
+     * Note that this can be `undefined` because an error could have occurred before the
+     * `RouterStateSnapshot` was created for the navigation.
+     */
+    target) {
         super(id, url);
         this.error = error;
+        this.target = target;
         this.type = 3 /* EventType.NavigationError */;
     }
     /** @docsNotRequired */
@@ -2233,6 +2247,37 @@ function createActivatedRoute(c) {
     return new ActivatedRoute(new BehaviorSubject(c.url), new BehaviorSubject(c.params), new BehaviorSubject(c.queryParams), new BehaviorSubject(c.fragment), new BehaviorSubject(c.data), c.outlet, c.component, c);
 }
 
+/**
+ * @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 NAVIGATION_CANCELING_ERROR = 'ngNavigationCancelingError';
+function redirectingNavigationError(urlSerializer, redirect) {
+    const { redirectTo, navigationBehaviorOptions } = isUrlTree(redirect) ? { redirectTo: redirect, navigationBehaviorOptions: undefined } : redirect;
+    const error = navigationCancelingError(ngDevMode && `Redirecting to "${urlSerializer.serialize(redirectTo)}"`, 0 /* NavigationCancellationCode.Redirect */, redirect);
+    error.url = redirectTo;
+    error.navigationBehaviorOptions = navigationBehaviorOptions;
+    return error;
+}
+function navigationCancelingError(message, code, redirectUrl) {
+    const error = new Error('NavigationCancelingError: ' + (message || ''));
+    error[NAVIGATION_CANCELING_ERROR] = true;
+    error.cancellationCode = code;
+    if (redirectUrl) {
+        error.url = redirectUrl;
+    }
+    return error;
+}
+function isRedirectingNavigationCancelingError$1(error) {
+    return isNavigationCancelingError$1(error) && isUrlTree(error.url);
+}
+function isNavigationCancelingError$1(error) {
+    return error && error[NAVIGATION_CANCELING_ERROR];
+}
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -2319,6 +2364,7 @@ class ChildrenOutletContexts {
  * 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;
 /**
  * @description
  *
@@ -2428,12 +2474,12 @@ class RouterOutlet {
      */
     get component() {
         if (!this.activated)
-            throw new Error('Outlet is not activated');
+            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$5 && 'Outlet is not activated');
         return this.activated.instance;
     }
     get activatedRoute() {
         if (!this.activated)
-            throw new Error('Outlet is not activated');
+            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$5 && 'Outlet is not activated');
         return this._activatedRoute;
     }
     get activatedRouteData() {
@@ -2447,7 +2493,7 @@ class RouterOutlet {
      */
     detach() {
         if (!this.activated)
-            throw new Error('Outlet is not activated');
+            throw new ɵRuntimeError(4012 /* RuntimeErrorCode.OUTLET_NOT_ACTIVATED */, NG_DEV_MODE$5 && 'Outlet is not activated');
         this.location.detach();
         const cmp = this.activated;
         this.activated = null;
@@ -2475,7 +2521,7 @@ class RouterOutlet {
     }
     activateWith(activatedRoute, resolverOrInjector) {
         if (this.isActivated) {
-            throw new Error('Cannot activate an already activated outlet');
+            throw new ɵRuntimeError(4013 /* RuntimeErrorCode.OUTLET_ALREADY_ACTIVATED */, NG_DEV_MODE$5 && 'Cannot activate an already activated outlet');
         }
         this._activatedRoute = activatedRoute;
         const location = this.location;
@@ -2497,9 +2543,9 @@ class RouterOutlet {
         this.activateEvents.emit(this.activated.instance);
     }
 }
-RouterOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterOutlet, deps: [{ token: ChildrenOutletContexts }, { token: i0.ViewContainerRef }, { token: 'name', attribute: true }, { token: i0.ChangeDetectorRef }, { token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Directive });
-RouterOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0-next.3", type: RouterOutlet, selector: "router-outlet", outputs: { activateEvents: "activate", deactivateEvents: "deactivate", attachEvents: "attach", detachEvents: "detach" }, exportAs: ["outlet"], ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterOutlet, decorators: [{
+RouterOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterOutlet, deps: [{ token: ChildrenOutletContexts }, { token: i0.ViewContainerRef }, { token: 'name', attribute: true }, { token: i0.ChangeDetectorRef }, { token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Directive });
+RouterOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0", type: RouterOutlet, selector: "router-outlet", outputs: { activateEvents: "activate", deactivateEvents: "deactivate", attachEvents: "attach", detachEvents: "detach" }, exportAs: ["outlet"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterOutlet, decorators: [{
             type: Directive,
             args: [{ selector: 'router-outlet', exportAs: 'outlet' }]
         }], ctorParameters: function () {
@@ -2558,9 +2604,9 @@ function isComponentFactoryResolver(item) {
  */
 class ɵEmptyOutletComponent {
 }
-ɵEmptyOutletComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-ɵEmptyOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0-next.3", type: ɵEmptyOutletComponent, selector: "ng-component", ngImport: i0, template: `<router-outlet></router-outlet>`, isInline: true, dependencies: [{ kind: "directive", type: RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: ɵEmptyOutletComponent, decorators: [{
+ɵEmptyOutletComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ɵEmptyOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: ɵEmptyOutletComponent, selector: "ng-component", ngImport: i0, template: `<router-outlet></router-outlet>`, isInline: true, dependencies: [{ kind: "directive", type: RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ɵEmptyOutletComponent, decorators: [{
             type: Component,
             args: [{ template: `<router-outlet></router-outlet>` }]
         }] });
@@ -2610,13 +2656,13 @@ function validateConfig(config, parentPath = '', requireStandaloneComponents = f
 }
 function assertStandalone(fullPath, component) {
     if (component && !ɵisStandalone(component)) {
-        throw new Error(`Invalid configuration of route '${fullPath}'. The component must be standalone.`);
+        throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}'. The component must be standalone.`);
     }
 }
 function validateNode(route, fullPath, requireStandaloneComponents) {
     if (typeof ngDevMode === 'undefined' || ngDevMode) {
         if (!route) {
-            throw new Error(`
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `
       Invalid configuration of route '${fullPath}': Encountered undefined route.
       The reason might be an extra comma.
 
@@ -2629,47 +2675,47 @@ function validateNode(route, fullPath, requireStandaloneComponents) {
     `);
         }
         if (Array.isArray(route)) {
-            throw new Error(`Invalid configuration of route '${fullPath}': Array cannot be specified`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}': Array cannot be specified`);
         }
         if (!route.component && !route.loadComponent && !route.children && !route.loadChildren &&
             (route.outlet && route.outlet !== PRIMARY_OUTLET)) {
-            throw new Error(`Invalid configuration of route '${fullPath}': a componentless route without children or loadChildren cannot have a named outlet set`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}': a componentless route without children or loadChildren cannot have a named outlet set`);
         }
         if (route.redirectTo && route.children) {
-            throw new Error(`Invalid configuration of route '${fullPath}': redirectTo and children cannot be used together`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}': redirectTo and children cannot be used together`);
         }
         if (route.redirectTo && route.loadChildren) {
-            throw new Error(`Invalid configuration of route '${fullPath}': redirectTo and loadChildren cannot be used together`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}': redirectTo and loadChildren cannot be used together`);
         }
         if (route.children && route.loadChildren) {
-            throw new Error(`Invalid configuration of route '${fullPath}': children and loadChildren cannot be used together`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}': children and loadChildren cannot be used together`);
         }
         if (route.redirectTo && (route.component || route.loadComponent)) {
-            throw new Error(`Invalid configuration of route '${fullPath}': redirectTo and component/loadComponent cannot be used together`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}': redirectTo and component/loadComponent cannot be used together`);
         }
         if (route.component && route.loadComponent) {
-            throw new Error(`Invalid configuration of route '${fullPath}': component and loadComponent cannot be used together`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}': component and loadComponent cannot be used together`);
         }
         if (route.redirectTo && route.canActivate) {
-            throw new Error(`Invalid configuration of route '${fullPath}': redirectTo and canActivate cannot be used together. Redirects happen before activation ` +
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}': redirectTo and canActivate cannot be used together. Redirects happen before activation ` +
                 `so canActivate will never be executed.`);
         }
         if (route.path && route.matcher) {
-            throw new Error(`Invalid configuration of route '${fullPath}': path and matcher cannot be used together`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}': path and matcher cannot be used together`);
         }
         if (route.redirectTo === void 0 && !route.component && !route.loadComponent &&
             !route.children && !route.loadChildren) {
-            throw new Error(`Invalid configuration of route '${fullPath}'. One of the following must be provided: component, loadComponent, redirectTo, children or loadChildren`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}'. One of the following must be provided: component, loadComponent, redirectTo, children or loadChildren`);
         }
         if (route.path === void 0 && route.matcher === void 0) {
-            throw new Error(`Invalid configuration of route '${fullPath}': routes must have either a path or a matcher specified`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}': routes must have either a path or a matcher specified`);
         }
         if (typeof route.path === 'string' && route.path.charAt(0) === '/') {
-            throw new Error(`Invalid configuration of route '${fullPath}': path cannot start with a slash`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '${fullPath}': path cannot start with a slash`);
         }
         if (route.path === '' && route.redirectTo !== void 0 && route.pathMatch === void 0) {
             const exp = `The default value of 'pathMatch' is 'prefix', but often the intent is to use 'full'.`;
-            throw new Error(`Invalid configuration of route '{path: "${fullPath}", redirectTo: "${route.redirectTo}"}': please provide 'pathMatch'. ${exp}`);
+            throw new ɵRuntimeError(4014 /* RuntimeErrorCode.INVALID_ROUTE_CONFIG */, `Invalid configuration of route '{path: "${fullPath}", redirectTo: "${route.redirectTo}"}': please provide 'pathMatch'. ${exp}`);
         }
         if (requireStandaloneComponents) {
             assertStandalone(fullPath, route.component);
@@ -3099,9 +3145,6 @@ function isFunction(v) {
 function isBoolean(v) {
     return typeof v === 'boolean';
 }
-function isUrlTree(v) {
-    return v instanceof UrlTree;
-}
 function isCanLoad(guard) {
     return guard && isFunction(guard.canLoad);
 }
@@ -3117,6 +3160,12 @@ function isCanDeactivate(guard) {
 function isCanMatch(guard) {
     return guard && isFunction(guard.canMatch);
 }
+function isRedirectingNavigationCancelingError(error) {
+    return isNavigationCancelingError(error) && isUrlTree(error.url);
+}
+function isNavigationCancelingError(error) {
+    return error && error[NAVIGATION_CANCELING_ERROR];
+}
 
 /**
  * @license
@@ -3129,31 +3178,26 @@ const INITIAL_VALUE = Symbol('INITIAL_VALUE');
 function prioritizedGuardValue() {
     return switchMap(obs => {
         return combineLatest(obs.map(o => o.pipe(take(1), startWith(INITIAL_VALUE))))
-            .pipe(scan((acc, list) => {
-            let isPending = false;
-            return list.reduce((innerAcc, val, i) => {
-                if (innerAcc !== INITIAL_VALUE)
-                    return innerAcc;
-                // Toggle pending flag if any values haven't been set yet
-                if (val === INITIAL_VALUE)
-                    isPending = true;
-                // Any other return values are only valid if we haven't yet hit a pending
-                // call. This guarantees that in the case of a guard at the bottom of the
-                // tree that returns a redirect, we will wait for the higher priority
-                // guard at the top to finish before performing the redirect.
-                if (!isPending) {
-                    // Early return when we hit a `false` value as that should always
-                    // cancel navigation
-                    if (val === false)
-                        return val;
-                    if (i === list.length - 1 || isUrlTree(val)) {
-                        return val;
-                    }
+            .pipe(map((results) => {
+            for (const result of results) {
+                if (result === true) {
+                    // If result is true, check the next one
+                    continue;
+                }
+                else if (result === INITIAL_VALUE) {
+                    // If guard has not finished, we need to stop processing.
+                    return INITIAL_VALUE;
                 }
-                return innerAcc;
-            }, acc);
-        }, INITIAL_VALUE), filter(item => item !== INITIAL_VALUE), map(item => isUrlTree(item) ? item : item === true), //
-        take(1));
+                else if (result === false || result instanceof UrlTree) {
+                    // Result finished and was not true. Return the result.
+                    // Note that we only allow false/UrlTree. Other values are considered invalid and
+                    // ignored.
+                    return result;
+                }
+            }
+            // Everything resolved to true. Return true.
+            return true;
+        }), filter((item) => item !== INITIAL_VALUE), take(1));
     });
 }
 
@@ -3225,17 +3269,9 @@ function runCanActivate(futureRSS, futureARS, moduleInjector) {
     const canActivateObservables = canActivate.map((c) => {
         return defer(() => {
             const guard = getToken(c, futureARS, moduleInjector);
-            let observable;
-            if (isCanActivate(guard)) {
-                observable = wrapIntoObservable(guard.canActivate(futureARS, futureRSS));
-            }
-            else if (isFunction(guard)) {
-                observable = wrapIntoObservable(guard(futureARS, futureRSS));
-            }
-            else {
-                throw new Error('Invalid CanActivate guard');
-            }
-            return observable.pipe(first());
+            const guardVal = isCanActivate(guard) ? guard.canActivate(futureARS, futureRSS) :
+                guard(futureARS, futureRSS);
+            return wrapIntoObservable(guardVal).pipe(first());
         });
     });
     return of(canActivateObservables).pipe(prioritizedGuardValue());
@@ -3250,17 +3286,9 @@ function runCanActivateChild(futureRSS, path, moduleInjector) {
         return defer(() => {
             const guardsMapped = d.guards.map((c) => {
                 const guard = getToken(c, d.node, moduleInjector);
-                let observable;
-                if (isCanActivateChild(guard)) {
-                    observable = wrapIntoObservable(guard.canActivateChild(futureARS, futureRSS));
-                }
-                else if (isFunction(guard)) {
-                    observable = wrapIntoObservable(guard(futureARS, futureRSS));
-                }
-                else {
-                    throw new Error('Invalid CanActivateChild guard');
-                }
-                return observable.pipe(first());
+                const guardVal = isCanActivateChild(guard) ? guard.canActivateChild(futureARS, futureRSS) :
+                    guard(futureARS, futureRSS);
+                return wrapIntoObservable(guardVal).pipe(first());
             });
             return of(guardsMapped).pipe(prioritizedGuardValue());
         });
@@ -3273,17 +3301,10 @@ function runCanDeactivate(component, currARS, currRSS, futureRSS, moduleInjector
         return of(true);
     const canDeactivateObservables = canDeactivate.map((c) => {
         const guard = getToken(c, currARS, moduleInjector);
-        let observable;
-        if (isCanDeactivate(guard)) {
-            observable = wrapIntoObservable(guard.canDeactivate(component, currARS, currRSS, futureRSS));
-        }
-        else if (isFunction(guard)) {
-            observable = wrapIntoObservable(guard(component, currARS, currRSS, futureRSS));
-        }
-        else {
-            throw new Error('Invalid CanDeactivate guard');
-        }
-        return observable.pipe(first());
+        const guardVal = isCanDeactivate(guard) ?
+            guard.canDeactivate(component, currARS, currRSS, futureRSS) :
+            guard(component, currARS, currRSS, futureRSS);
+        return wrapIntoObservable(guardVal).pipe(first());
     });
     return of(canDeactivateObservables).pipe(prioritizedGuardValue());
 }
@@ -3294,16 +3315,7 @@ function runCanLoadGuards(injector, route, segments, urlSerializer) {
     }
     const canLoadObservables = canLoad.map((injectionToken) => {
         const guard = injector.get(injectionToken);
-        let guardVal;
-        if (isCanLoad(guard)) {
-            guardVal = guard.canLoad(route, segments);
-        }
-        else if (isFunction(guard)) {
-            guardVal = guard(route, segments);
-        }
-        else {
-            throw new Error('Invalid CanLoad guard');
-        }
+        const guardVal = isCanLoad(guard) ? guard.canLoad(route, segments) : guard(route, segments);
         return wrapIntoObservable(guardVal);
     });
     return of(canLoadObservables)
@@ -3313,9 +3325,7 @@ function redirectIfUrlTree(urlSerializer) {
     return pipe(tap((result) => {
         if (!isUrlTree(result))
             return;
-        const error = navigationCancelingError(`Redirecting to "${urlSerializer.serialize(result)}"`);
-        error.url = result;
-        throw error;
+        throw redirectingNavigationError(urlSerializer, result);
     }), map(result => result === true));
 }
 function runCanMatchGuards(injector, route, segments, urlSerializer) {
@@ -3493,6 +3503,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$4 = typeof ngDevMode === 'undefined' || ngDevMode;
 class NoMatch$1 {
     constructor(segmentGroup) {
         this.segmentGroup = segmentGroup || null;
@@ -3510,10 +3521,12 @@ function absoluteRedirect(newTree) {
     return throwError(new AbsoluteRedirect(newTree));
 }
 function namedOutletsRedirect(redirectTo) {
-    return throwError(new Error(`Only absolute redirects can have named outlets. redirectTo: '${redirectTo}'`));
+    return throwError(new ɵRuntimeError(4000 /* RuntimeErrorCode.NAMED_OUTLET_REDIRECT */, NG_DEV_MODE$4 &&
+        `Only absolute redirects can have named outlets. redirectTo: '${redirectTo}'`));
 }
 function canLoadFails(route) {
-    return throwError(navigationCancelingError(`Cannot load children because the guard of the route "path: '${route.path}'" returned false`));
+    return throwError(navigationCancelingError(NG_DEV_MODE$4 &&
+        `Cannot load children because the guard of the route "path: '${route.path}'" returned false`, 3 /* NavigationCancellationCode.GuardRejected */));
 }
 /**
  * Returns the `UrlTree` with the redirection applied.
@@ -3572,7 +3585,7 @@ class ApplyRedirects {
         }));
     }
     noMatchError(e) {
-        return new Error(`Cannot match any routes. URL Segment: '${e.segmentGroup}'`);
+        return new ɵRuntimeError(4002 /* RuntimeErrorCode.NO_MATCH */, NG_DEV_MODE$4 && `Cannot match any routes. URL Segment: '${e.segmentGroup}'`);
     }
     createUrlTree(rootCandidate, queryParams, fragment) {
         const root = createRoot(rootCandidate);
@@ -3754,9 +3767,9 @@ class ApplyRedirects {
         }
     }
     applyRedirectCommands(segments, redirectTo, posParams) {
-        return this.applyRedirectCreatreUrlTree(redirectTo, this.urlSerializer.parse(redirectTo), segments, posParams);
+        return this.applyRedirectCreateUrlTree(redirectTo, this.urlSerializer.parse(redirectTo), segments, posParams);
     }
-    applyRedirectCreatreUrlTree(redirectTo, urlTree, segments, posParams) {
+    applyRedirectCreateUrlTree(redirectTo, urlTree, segments, posParams) {
         const newRoot = this.createSegmentGroup(redirectTo, urlTree.root, segments, posParams);
         return new UrlTree(newRoot, this.createQueryParams(urlTree.queryParams, this.urlTree.queryParams), urlTree.fragment);
     }
@@ -3789,7 +3802,8 @@ class ApplyRedirects {
     findPosParam(redirectTo, redirectToUrlSegment, posParams) {
         const pos = posParams[redirectToUrlSegment.path.substring(1)];
         if (!pos)
-            throw new Error(`Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);
+            throw new ɵRuntimeError(4001 /* RuntimeErrorCode.MISSING_REDIRECT */, NG_DEV_MODE$4 &&
+                `Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);
         return pos;
     }
     findOrReturn(redirectToUrlSegment, actualSegments) {
@@ -3913,7 +3927,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 (typeof ngDevMode === 'undefined' || ngDevMode) {
+            if (NG_DEV_MODE$3) {
                 // This should really never happen - we are only taking the first match for each
                 // outlet and merge the empty path matches.
                 checkOutletNameUniqueness(mergedChildren);
@@ -4079,7 +4093,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 Error(`Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
+            throw new ɵRuntimeError(4006 /* RuntimeErrorCode.TWO_SEGMENTS_WITH_SAME_OUTLET */, NG_DEV_MODE$3 && `Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
         }
         names[n.value.outlet] = n.value;
     });
@@ -4388,9 +4402,9 @@ class RouterConfigLoader {
         }));
     }
 }
-RouterConfigLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterConfigLoader, deps: [{ token: i0.Injector }, { token: i0.Compiler }], target: i0.ɵɵFactoryTarget.Injectable });
-RouterConfigLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterConfigLoader });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterConfigLoader, decorators: [{
+RouterConfigLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.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: "14.1.0", ngImport: i0, type: RouterConfigLoader });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterConfigLoader, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.Compiler }]; } });
 
@@ -4641,10 +4655,11 @@ class Router {
         // 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(t => {
+        switchMap(overallTransitionState => {
             let completed = false;
             let errored = false;
-            return of(t).pipe(
+            return of(overallTransitionState)
+                .pipe(
             // Store the Navigation object
             tap(t => {
                 this.currentNavigation = {
@@ -4662,8 +4677,8 @@ class Router {
                     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.
+                    // 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);
@@ -4691,11 +4706,13 @@ class Router {
                     // `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, this.relativeLinkResolution), 
                     // 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);
@@ -4711,21 +4728,22 @@ class Router {
                 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.*/
+                    /* 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;
-                        return of(Object.assign(Object.assign({}, t), { targetSnapshot, urlAfterRedirects: extractedUrl, extras: Object.assign(Object.assign({}, extras), { skipLocationChange: false, replaceUrl: false }) }));
+                        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.
+                        /* 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);
@@ -4737,18 +4755,20 @@ class Router {
             tap(t => {
                 const guardsStart = new GuardsCheckStart(t.id, this.serializeUrl(t.extractedUrl), this.serializeUrl(t.urlAfterRedirects), t.targetSnapshot);
                 this.triggerEvent(guardsStart);
-            }), map(t => (Object.assign(Object.assign({}, t), { guards: getAllRouteGuards(t.targetSnapshot, t.currentSnapshot, this.rootContexts) }))), checkGuards(this.ngModule.injector, (evt) => this.triggerEvent(evt)), tap(t => {
+            }), 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)) {
-                    const error = navigationCancelingError(`Redirecting to "${this.serializeUrl(t.guardsResult)}"`);
-                    error.url = t.guardsResult;
-                    throw error;
+                    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, '');
+                    this.cancelNavigationTransition(t, '', 3 /* NavigationCancellationCode.GuardRejected */);
                     return false;
                 }
                 return true;
@@ -4766,7 +4786,9 @@ class Router {
                             complete: () => {
                                 if (!dataResolved) {
                                     this.restoreHistory(t);
-                                    this.cancelNavigationTransition(t, `At least one route resolver didn't emit any value.`);
+                                    this.cancelNavigationTransition(t, NG_DEV_MODE$1 ?
+                                        `At least one route resolver didn't emit any value.` :
+                                        '', 2 /* NavigationCancellationCode.NoDataFromResolver */);
                                 }
                             }
                         }));
@@ -4776,7 +4798,7 @@ class Router {
                     }));
                 }
                 return undefined;
-            }), switchTap(() => this.afterPreactivation()), 
+            }), 
             // --- LOAD COMPONENTS ---
             switchTap((t) => {
                 const loadComponents = (route) => {
@@ -4796,15 +4818,16 @@ class Router {
                 };
                 return combineLatest(loadComponents(t.targetSnapshot.root))
                     .pipe(defaultIfEmpty(), take(1));
-            }), map((t) => {
+            }), switchTap(() => this.afterPreactivation()), map((t) => {
                 const targetRouterState = createRouterState(this.routeReuseStrategy, t.targetSnapshot, t.currentRouterState);
-                return (Object.assign(Object.assign({}, t), { targetRouterState }));
+                overallTransitionState = Object.assign(Object.assign({}, t), { targetRouterState });
+                return (overallTransitionState);
             }), 
-            /* Once here, we are about to activate syncronously. 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. */
+            /* 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 =
@@ -4825,80 +4848,76 @@ class Router {
                 }
             }), 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. */
+                /* 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 = `Navigation ID ${t.id} is not equal to the current navigation id ${this.navigationId}`;
-                    this.cancelNavigationTransition(t, cancelationReason);
+                    const cancelationReason = NG_DEV_MODE$1 ?
+                        `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) === t.id) {
+                if (((_a = this.currentNavigation) === null || _a === void 0 ? void 0 : _a.id) === overallTransitionState.id) {
                     this.currentNavigation = null;
                 }
             }), catchError((e) => {
-                // TODO(atscott): The NavigationTransition `t` used here does not accurately
-                // reflect the current state of the whole transition because some operations
-                // return a new object rather than modifying the one in the outermost
-                // `switchMap`.
-                //  The fix can likely be to:
-                //  1. Rename the outer `t` variable so it's not shadowed all the time and
-                //  confusing
-                //  2. Keep reassigning to the outer variable after each stage to ensure it
-                //  gets updated. Or change the implementations to not return a copy.
-                // Not changed yet because it affects existing code and would need to be
-                // tested more thoroughly.
+                var _a;
                 errored = true;
                 /* This error type is issued during Redirect, and is handled as a
                  * cancellation rather than an error. */
-                if (isNavigationCancelingError(e)) {
-                    const redirecting = isUrlTree(e.url);
-                    if (!redirecting) {
-                        // 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.
+                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(t, true);
+                        this.restoreHistory(overallTransitionState, true);
                     }
-                    const navCancel = new NavigationCancel(t.id, this.serializeUrl(t.extractedUrl), e.message);
+                    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 (!redirecting) {
-                        t.resolve(false);
+                    if (!isRedirectingNavigationCancelingError$1(e)) {
+                        overallTransitionState.resolve(false);
                     }
                     else {
                         const mergedTree = this.urlHandlingStrategy.merge(e.url, this.rawUrlTree);
                         const extras = {
-                            skipLocationChange: t.extras.skipLocationChange,
+                            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.
+                            // button, URL bar, etc). We want to replace that item in history
+                            // if the navigation is rejected.
                             replaceUrl: this.urlUpdateStrategy === 'eager' ||
-                                isBrowserTriggeredNavigation(t.source)
+                                isBrowserTriggeredNavigation(overallTransitionState.source)
                         };
-                        this.scheduleNavigation(mergedTree, 'imperative', null, extras, { resolve: t.resolve, reject: t.reject, promise: t.promise });
+                        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. */
+                    /* All other errors should reset to the router's internal URL reference
+                     * to the pre-error state. */
                 }
                 else {
-                    this.restoreHistory(t, true);
-                    const navError = new NavigationError(t.id, this.serializeUrl(t.extractedUrl), e);
+                    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 {
-                        t.resolve(this.errorHandler(e));
+                        overallTransitionState.resolve(this.errorHandler(e));
                     }
                     catch (ee) {
-                        t.reject(ee);
+                        overallTransitionState.reject(ee);
                     }
                 }
                 return EMPTY;
@@ -5296,7 +5315,7 @@ class Router {
             // 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 `urlUpdateSrategy` is `eager`; `setBrowserUrl` method is called
+            // 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));
@@ -5342,8 +5361,8 @@ class Router {
     resetUrlToCurrentUrlTree() {
         this.location.replaceState(this.urlSerializer.serialize(this.rawUrlTree), '', this.generateNgRouterState(this.lastSuccessfulId, this.currentPageId));
     }
-    cancelNavigationTransition(t, reason) {
-        const navCancel = new NavigationCancel(t.id, this.serializeUrl(t.extractedUrl), reason);
+    cancelNavigationTransition(t, reason, code) {
+        const navCancel = new NavigationCancel(t.id, this.serializeUrl(t.extractedUrl), reason, code);
         this.triggerEvent(navCancel);
         t.resolve(false);
     }
@@ -5354,16 +5373,16 @@ class Router {
         return { navigationId };
     }
 }
-Router.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: Router, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
-Router.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: Router });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: Router, decorators: [{
+Router.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: Router, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+Router.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: Router });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: Router, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i0.Type }, { type: UrlSerializer }, { type: ChildrenOutletContexts }, { type: i3.Location }, { type: i0.Injector }, { type: i0.Compiler }, { type: undefined }]; } });
 function validateCommands(commands) {
     for (let i = 0; i < commands.length; i++) {
         const cmd = commands[i];
         if (cmd == null) {
-            throw new Error(`The requested path contains ${cmd} segment at index ${i}`);
+            throw new ɵRuntimeError(4008 /* RuntimeErrorCode.NULLISH_COMMAND */, NG_DEV_MODE$1 && `The requested path contains ${cmd} segment at index ${i}`);
         }
     }
 }
@@ -5548,9 +5567,9 @@ class RouterLink {
         });
     }
 }
-RouterLink.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterLink, deps: [{ token: Router }, { token: ActivatedRoute }, { token: 'tabindex', attribute: true }, { token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-RouterLink.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0-next.3", type: RouterLink, selector: ":not(a):not(area)[routerLink]", inputs: { queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", preserveFragment: "preserveFragment", skipLocationChange: "skipLocationChange", replaceUrl: "replaceUrl", state: "state", relativeTo: "relativeTo", routerLink: "routerLink" }, host: { listeners: { "click": "onClick()" } }, usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterLink, decorators: [{
+RouterLink.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterLink, deps: [{ token: Router }, { token: ActivatedRoute }, { token: 'tabindex', attribute: true }, { token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+RouterLink.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0", type: RouterLink, selector: ":not(a):not(area)[routerLink]", inputs: { queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", preserveFragment: "preserveFragment", skipLocationChange: "skipLocationChange", replaceUrl: "replaceUrl", state: "state", relativeTo: "relativeTo", routerLink: "routerLink" }, host: { listeners: { "click": "onClick()" } }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterLink, decorators: [{
             type: Directive,
             args: [{ selector: ':not(a):not(area)[routerLink]' }]
         }], ctorParameters: function () {
@@ -5669,9 +5688,9 @@ class RouterLinkWithHref {
         });
     }
 }
-RouterLinkWithHref.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterLinkWithHref, deps: [{ token: Router }, { token: ActivatedRoute }, { token: i3.LocationStrategy }], target: i0.ɵɵFactoryTarget.Directive });
-RouterLinkWithHref.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0-next.3", type: RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: { target: "target", queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", preserveFragment: "preserveFragment", skipLocationChange: "skipLocationChange", replaceUrl: "replaceUrl", state: "state", relativeTo: "relativeTo", routerLink: "routerLink" }, host: { listeners: { "click": "onClick($event.button,$event.ctrlKey,$event.shiftKey,$event.altKey,$event.metaKey)" }, properties: { "attr.target": "this.target", "attr.href": "this.href" } }, usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterLinkWithHref, decorators: [{
+RouterLinkWithHref.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterLinkWithHref, deps: [{ token: Router }, { token: ActivatedRoute }, { token: i3.LocationStrategy }], target: i0.ɵɵFactoryTarget.Directive });
+RouterLinkWithHref.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0", type: RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: { target: "target", queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", preserveFragment: "preserveFragment", skipLocationChange: "skipLocationChange", replaceUrl: "replaceUrl", state: "state", relativeTo: "relativeTo", routerLink: "routerLink" }, host: { listeners: { "click": "onClick($event.button,$event.ctrlKey,$event.shiftKey,$event.altKey,$event.metaKey)" }, properties: { "attr.target": "this.target", "attr.href": "this.href" } }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterLinkWithHref, decorators: [{
             type: Directive,
             args: [{ selector: 'a[routerLink],area[routerLink]' }]
         }], ctorParameters: function () { return [{ type: Router }, { type: ActivatedRoute }, { type: i3.LocationStrategy }]; }, propDecorators: { target: [{
@@ -5898,9 +5917,9 @@ class RouterLinkActive {
             this.links.some(isActiveCheckFn) || this.linksWithHrefs.some(isActiveCheckFn);
     }
 }
-RouterLinkActive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterLinkActive, deps: [{ token: Router }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: RouterLink, optional: true }, { token: RouterLinkWithHref, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
-RouterLinkActive.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0-next.3", type: RouterLinkActive, selector: "[routerLinkActive]", inputs: { routerLinkActiveOptions: "routerLinkActiveOptions", ariaCurrentWhenActive: "ariaCurrentWhenActive", routerLinkActive: "routerLinkActive" }, outputs: { isActiveChange: "isActiveChange" }, queries: [{ propertyName: "links", predicate: RouterLink, descendants: true }, { propertyName: "linksWithHrefs", predicate: RouterLinkWithHref, descendants: true }], exportAs: ["routerLinkActive"], usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterLinkActive, decorators: [{
+RouterLinkActive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterLinkActive, deps: [{ token: Router }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: RouterLink, optional: true }, { token: RouterLinkWithHref, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+RouterLinkActive.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0", type: RouterLinkActive, selector: "[routerLinkActive]", inputs: { routerLinkActiveOptions: "routerLinkActiveOptions", ariaCurrentWhenActive: "ariaCurrentWhenActive", routerLinkActive: "routerLinkActive" }, outputs: { isActiveChange: "isActiveChange" }, queries: [{ propertyName: "links", predicate: RouterLink, descendants: true }, { propertyName: "linksWithHrefs", predicate: RouterLinkWithHref, descendants: true }], exportAs: ["routerLinkActive"], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterLinkActive, decorators: [{
             type: Directive,
             args: [{
                     selector: '[routerLinkActive]',
@@ -5986,6 +6005,12 @@ class TitleStrategy {
         return snapshot.data[RouteTitle];
     }
 }
+TitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: TitleStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TitleStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: TitleStrategy, providedIn: 'root', useFactory: () => inject(DefaultTitleStrategy) });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.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.
  */
@@ -6006,9 +6031,9 @@ class DefaultTitleStrategy extends TitleStrategy {
         }
     }
 }
-DefaultTitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: DefaultTitleStrategy, deps: [{ token: i1.Title }], target: i0.ɵɵFactoryTarget.Injectable });
-DefaultTitleStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: DefaultTitleStrategy, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: DefaultTitleStrategy, decorators: [{
+DefaultTitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: DefaultTitleStrategy, deps: [{ token: i1.Title }], target: i0.ɵɵFactoryTarget.Injectable });
+DefaultTitleStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: DefaultTitleStrategy, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: DefaultTitleStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i1.Title }]; } });
@@ -6045,9 +6070,9 @@ class PreloadAllModules {
         return fn().pipe(catchError(() => of(null)));
     }
 }
-PreloadAllModules.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: PreloadAllModules, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-PreloadAllModules.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: PreloadAllModules, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: PreloadAllModules, decorators: [{
+PreloadAllModules.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: PreloadAllModules, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PreloadAllModules.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: PreloadAllModules, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: PreloadAllModules, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -6065,9 +6090,9 @@ class NoPreloading {
         return of(null);
     }
 }
-NoPreloading.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: NoPreloading, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-NoPreloading.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: NoPreloading, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: NoPreloading, decorators: [{
+NoPreloading.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: NoPreloading, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NoPreloading.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: NoPreloading, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: NoPreloading, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -6155,9 +6180,9 @@ class RouterPreloader {
         });
     }
 }
-RouterPreloader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", 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: "14.1.0-next.3", ngImport: i0, type: RouterPreloader });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterPreloader, decorators: [{
+RouterPreloader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.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: "14.1.0", ngImport: i0, type: RouterPreloader });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterPreloader, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: Router }, { type: i0.Compiler }, { type: i0.EnvironmentInjector }, { type: PreloadingStrategy }, { type: RouterConfigLoader }]; } });
 
@@ -6237,9 +6262,9 @@ class RouterScroller {
         }
     }
 }
-RouterScroller.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
-RouterScroller.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterScroller });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterScroller, decorators: [{
+RouterScroller.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+RouterScroller.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterScroller });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterScroller, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: Router }, { type: i3.ViewportScroller }, { type: undefined }]; } });
 
@@ -6276,9 +6301,9 @@ const ROUTER_PROVIDERS = [
         provide: Router,
         useFactory: setupRouter,
         deps: [
-            UrlSerializer, ChildrenOutletContexts, Location, Injector, Compiler, ROUTES,
-            ROUTER_CONFIGURATION, DefaultTitleStrategy, [TitleStrategy, new Optional()],
-            [UrlHandlingStrategy, new Optional()], [RouteReuseStrategy, new Optional()]
+            UrlSerializer, ChildrenOutletContexts, Location, Injector, Compiler, ROUTES, TitleStrategy,
+            ROUTER_CONFIGURATION, [UrlHandlingStrategy, new Optional()],
+            [RouteReuseStrategy, new Optional()]
         ]
     },
     ChildrenOutletContexts,
@@ -6372,10 +6397,10 @@ class RouterModule {
         return { ngModule: RouterModule, providers: [provideRoutes(routes)] };
     }
 }
-RouterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterModule, deps: [{ token: ROUTER_FORROOT_GUARD, optional: true }, { token: Router, optional: true }], target: i0.ɵɵFactoryTarget.NgModule });
-RouterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterModule, declarations: [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive, ɵEmptyOutletComponent], exports: [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive, ɵEmptyOutletComponent] });
-RouterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.3", ngImport: i0, type: RouterModule, decorators: [{
+RouterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterModule, deps: [{ token: ROUTER_FORROOT_GUARD, optional: true }, { token: Router, optional: true }], target: i0.ɵɵFactoryTarget.NgModule });
+RouterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.0", ngImport: i0, type: RouterModule, declarations: [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive, ɵEmptyOutletComponent], exports: [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive, ɵEmptyOutletComponent] });
+RouterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: RouterModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: ROUTER_DIRECTIVES,
@@ -6413,7 +6438,7 @@ function providePathLocationStrategy() {
 }
 function provideForRootGuard(router) {
     if (NG_DEV_MODE && router) {
-        throw new Error(`RouterModule.forRoot() called twice. Lazy loaded modules should use RouterModule.forChild() instead.`);
+        throw new ɵRuntimeError(4007 /* RuntimeErrorCode.FOR_ROOT_CALLED_TWICE */, `RouterModule.forRoot() called twice. Lazy loaded modules should use RouterModule.forChild() instead.`);
     }
     return 'guarded';
 }
@@ -6439,7 +6464,7 @@ function provideRoutes(routes) {
         { provide: ROUTES, multi: true, useValue: routes },
     ];
 }
-function setupRouter(urlSerializer, contexts, location, injector, compiler, config, opts = {}, defaultTitleStrategy, titleStrategy, urlHandlingStrategy, routeReuseStrategy) {
+function setupRouter(urlSerializer, contexts, location, injector, compiler, config, titleStrategy, opts = {}, urlHandlingStrategy, routeReuseStrategy) {
     const router = new Router(null, urlSerializer, contexts, location, injector, compiler, flatten(config));
     if (urlHandlingStrategy) {
         router.urlHandlingStrategy = urlHandlingStrategy;
@@ -6447,7 +6472,7 @@ function setupRouter(urlSerializer, contexts, location, injector, compiler, conf
     if (routeReuseStrategy) {
         router.routeReuseStrategy = routeReuseStrategy;
     }
-    router.titleStrategy = titleStrategy !== null && titleStrategy !== void 0 ? titleStrategy : defaultTitleStrategy;
+    router.titleStrategy = titleStrategy;
     assignExtraOptionsToRouter(opts, router);
     return router;
 }
@@ -6540,17 +6565,50 @@ function provideEnabledBlockingInitialNavigation() {
             useFactory: (injector) => {
                 const locationInitialized = injector.get(LOCATION_INITIALIZED, Promise.resolve(null));
                 let initNavigation = false;
+                /**
+                 * Performs the given action once the router finishes its next/current navigation.
+                 *
+                 * If the navigation is canceled or errors without a redirect, the navigation is considered
+                 * complete. If the `NavigationEnd` event emits, the navigation is also considered complete.
+                 */
+                function afterNextNavigation(action) {
+                    const router = injector.get(Router);
+                    router.events
+                        .pipe(filter((e) => e instanceof NavigationEnd || e instanceof NavigationCancel ||
+                        e instanceof NavigationError), map(e => {
+                        if (e instanceof NavigationEnd) {
+                            // Navigation assumed to succeed if we get `ActivationStart`
+                            return true;
+                        }
+                        const redirecting = e instanceof NavigationCancel ?
+                            (e.code === 0 /* NavigationCancellationCode.Redirect */ ||
+                                e.code === 1 /* NavigationCancellationCode.SupersededByNewNavigation */) :
+                            false;
+                        return redirecting ? null : false;
+                    }), filter((result) => result !== null), take(1))
+                        .subscribe(() => {
+                        action();
+                    });
+                }
                 return () => {
                     return locationInitialized.then(() => {
                         return new Promise(resolve => {
                             const router = injector.get(Router);
                             const bootstrapDone = injector.get(BOOTSTRAP_DONE);
+                            afterNextNavigation(() => {
+                                // Unblock APP_INITIALIZER in case the initial navigation was canceled or errored
+                                // without a redirect.
+                                resolve(true);
+                                initNavigation = true;
+                            });
                             router.afterPreactivation = () => {
-                                // only the initial navigation should be delayed
+                                // 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) {
-                                    initNavigation = true;
-                                    resolve(true);
-                                    return bootstrapDone;
+                                    return bootstrapDone.closed ? of(void 0) : bootstrapDone;
                                     // subsequent navigations should not be delayed
                                 }
                                 else {
@@ -6622,7 +6680,7 @@ function providePreloading(preloadingStrategy) {
 /**
  * @publicApi
  */
-const VERSION = new Version('14.1.0-next.3');
+const VERSION = new Version('14.1.0');
 
 /**
  * @license