@angular/router 14.1.0-next.0 → 14.1.0-next.3

package/fesm2015/router.mjs

@@ -1,15 +1,15 @@
 /**
- * @license Angular v14.1.0-next.0
+ * @license Angular v14.1.0-next.3
  * (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, ApplicationRef, Version } from '@angular/core';
-import { from, of, BehaviorSubject, combineLatest, throwError, EmptyError, concat, defer, Observable, EMPTY, ConnectableObservable, Subject } from 'rxjs';
-import { map, switchMap, take, startWith, scan, filter, catchError, concatMap, last as last$1, first, mergeMap, tap, takeLast, mapTo, finalize, refCount, defaultIfEmpty, mergeAll } from 'rxjs/operators';
+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 { 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 * as i3 from '@angular/common';
-import { Location, LocationStrategy, PlatformLocation, APP_BASE_HREF, ViewportScroller, HashLocationStrategy, PathLocationStrategy, LOCATION_INITIALIZED } from '@angular/common';
+import { Location, LocationStrategy, HashLocationStrategy, PathLocationStrategy, ViewportScroller, LOCATION_INITIALIZED } from '@angular/common';
 import * as i1 from '@angular/platform-browser';
 
 /**
@@ -2395,7 +2395,11 @@ class RouterOutlet {
     }
     /** @nodoc */
     ngOnDestroy() {
-        this.parentContexts.onChildOutletDestroyed(this.name);
+        var _a;
+        // Ensure that the registered outlet is this one before removing it on the context.
+        if (((_a = this.parentContexts.getContext(this.name)) === null || _a === void 0 ? void 0 : _a.outlet) === this) {
+            this.parentContexts.onChildOutletDestroyed(this.name);
+        }
     }
     /** @nodoc */
     ngOnInit() {
@@ -2493,9 +2497,9 @@ class RouterOutlet {
         this.activateEvents.emit(this.activated.instance);
     }
 }
-RouterOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.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-next.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-next.0", ngImport: i0, type: RouterOutlet, decorators: [{
+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: [{
             type: Directive,
             args: [{ selector: 'router-outlet', exportAs: 'outlet' }]
         }], ctorParameters: function () {
@@ -2554,9 +2558,9 @@ function isComponentFactoryResolver(item) {
  */
 class ɵEmptyOutletComponent {
 }
-ɵEmptyOutletComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-ɵEmptyOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0-next.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-next.0", ngImport: i0, type: ɵEmptyOutletComponent, decorators: [{
+ɵ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: [{
             type: Component,
             args: [{ template: `<router-outlet></router-outlet>` }]
         }] });
@@ -2929,6 +2933,146 @@ class ActivateRoutes {
     }
 }
 
+/**
+ * @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
+ */
+class CanActivate {
+    constructor(path) {
+        this.path = path;
+        this.route = this.path[this.path.length - 1];
+    }
+}
+class CanDeactivate {
+    constructor(component, route) {
+        this.component = component;
+        this.route = route;
+    }
+}
+function getAllRouteGuards(future, curr, parentContexts) {
+    const futureRoot = future._root;
+    const currRoot = curr ? curr._root : null;
+    return getChildRouteGuards(futureRoot, currRoot, parentContexts, [futureRoot.value]);
+}
+function getCanActivateChild(p) {
+    const canActivateChild = p.routeConfig ? p.routeConfig.canActivateChild : null;
+    if (!canActivateChild || canActivateChild.length === 0)
+        return null;
+    return { node: p, guards: canActivateChild };
+}
+function getToken(token, snapshot, fallbackInjector) {
+    const routeInjector = getClosestRouteInjector(snapshot);
+    const injector = routeInjector !== null && routeInjector !== void 0 ? routeInjector : fallbackInjector;
+    return injector.get(token);
+}
+function getChildRouteGuards(futureNode, currNode, contexts, futurePath, checks = {
+    canDeactivateChecks: [],
+    canActivateChecks: []
+}) {
+    const prevChildren = nodeChildrenAsMap(currNode);
+    // Process the children of the future route
+    futureNode.children.forEach(c => {
+        getRouteGuards(c, prevChildren[c.value.outlet], contexts, futurePath.concat([c.value]), checks);
+        delete prevChildren[c.value.outlet];
+    });
+    // Process any children left from the current route (not active for the future route)
+    forEach(prevChildren, (v, k) => deactivateRouteAndItsChildren(v, contexts.getContext(k), checks));
+    return checks;
+}
+function getRouteGuards(futureNode, currNode, parentContexts, futurePath, checks = {
+    canDeactivateChecks: [],
+    canActivateChecks: []
+}) {
+    const future = futureNode.value;
+    const curr = currNode ? currNode.value : null;
+    const context = parentContexts ? parentContexts.getContext(futureNode.value.outlet) : null;
+    // reusing the node
+    if (curr && future.routeConfig === curr.routeConfig) {
+        const shouldRun = shouldRunGuardsAndResolvers(curr, future, future.routeConfig.runGuardsAndResolvers);
+        if (shouldRun) {
+            checks.canActivateChecks.push(new CanActivate(futurePath));
+        }
+        else {
+            // we need to set the data
+            future.data = curr.data;
+            future._resolvedData = curr._resolvedData;
+        }
+        // If we have a component, we need to go through an outlet.
+        if (future.component) {
+            getChildRouteGuards(futureNode, currNode, context ? context.children : null, futurePath, checks);
+            // if we have a componentless route, we recurse but keep the same outlet map.
+        }
+        else {
+            getChildRouteGuards(futureNode, currNode, parentContexts, futurePath, checks);
+        }
+        if (shouldRun && context && context.outlet && context.outlet.isActivated) {
+            checks.canDeactivateChecks.push(new CanDeactivate(context.outlet.component, curr));
+        }
+    }
+    else {
+        if (curr) {
+            deactivateRouteAndItsChildren(currNode, context, checks);
+        }
+        checks.canActivateChecks.push(new CanActivate(futurePath));
+        // If we have a component, we need to go through an outlet.
+        if (future.component) {
+            getChildRouteGuards(futureNode, null, context ? context.children : null, futurePath, checks);
+            // if we have a componentless route, we recurse but keep the same outlet map.
+        }
+        else {
+            getChildRouteGuards(futureNode, null, parentContexts, futurePath, checks);
+        }
+    }
+    return checks;
+}
+function shouldRunGuardsAndResolvers(curr, future, mode) {
+    if (typeof mode === 'function') {
+        return mode(curr, future);
+    }
+    switch (mode) {
+        case 'pathParamsChange':
+            return !equalPath(curr.url, future.url);
+        case 'pathParamsOrQueryParamsChange':
+            return !equalPath(curr.url, future.url) ||
+                !shallowEqual(curr.queryParams, future.queryParams);
+        case 'always':
+            return true;
+        case 'paramsOrQueryParamsChange':
+            return !equalParamsAndUrlSegments(curr, future) ||
+                !shallowEqual(curr.queryParams, future.queryParams);
+        case 'paramsChange':
+        default:
+            return !equalParamsAndUrlSegments(curr, future);
+    }
+}
+function deactivateRouteAndItsChildren(route, context, checks) {
+    const children = nodeChildrenAsMap(route);
+    const r = route.value;
+    forEach(children, (node, childName) => {
+        if (!r.component) {
+            deactivateRouteAndItsChildren(node, context, checks);
+        }
+        else if (context) {
+            deactivateRouteAndItsChildren(node, context.children.getContext(childName), checks);
+        }
+        else {
+            deactivateRouteAndItsChildren(node, null, checks);
+        }
+    });
+    if (!r.component) {
+        checks.canDeactivateChecks.push(new CanDeactivate(null, r));
+    }
+    else if (context && context.outlet && context.outlet.isActivated) {
+        checks.canDeactivateChecks.push(new CanDeactivate(context.outlet.component, r));
+    }
+    else {
+        checks.canDeactivateChecks.push(new CanDeactivate(null, r));
+    }
+}
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -2970,6 +3114,9 @@ function isCanActivateChild(guard) {
 function isCanDeactivate(guard) {
     return guard && isFunction(guard.canDeactivate);
 }
+function isCanMatch(guard) {
+    return guard && isFunction(guard.canMatch);
+}
 
 /**
  * @license
@@ -3017,91 +3164,276 @@ function prioritizedGuardValue() {
  * 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 noMatch$1 = {
-    matched: false,
-    consumedSegments: [],
-    remainingSegments: [],
-    parameters: {},
-    positionalParamSegments: {}
-};
-function match(segmentGroup, route, segments) {
-    var _a;
-    if (route.path === '') {
-        if (route.pathMatch === 'full' && (segmentGroup.hasChildren() || segments.length > 0)) {
-            return Object.assign({}, noMatch$1);
+function checkGuards(moduleInjector, forwardEvent) {
+    return mergeMap(t => {
+        const { targetSnapshot, currentSnapshot, guards: { canActivateChecks, canDeactivateChecks } } = t;
+        if (canDeactivateChecks.length === 0 && canActivateChecks.length === 0) {
+            return of(Object.assign(Object.assign({}, t), { guardsResult: true }));
         }
-        return {
-            matched: true,
-            consumedSegments: [],
-            remainingSegments: segments,
-            parameters: {},
-            positionalParamSegments: {}
-        };
-    }
-    const matcher = route.matcher || defaultUrlMatcher;
-    const res = matcher(segments, segmentGroup, route);
-    if (!res)
-        return Object.assign({}, noMatch$1);
-    const posParams = {};
-    forEach(res.posParams, (v, k) => {
-        posParams[k] = v.path;
+        return runCanDeactivateChecks(canDeactivateChecks, targetSnapshot, currentSnapshot, moduleInjector)
+            .pipe(mergeMap(canDeactivate => {
+            return canDeactivate && isBoolean(canDeactivate) ?
+                runCanActivateChecks(targetSnapshot, canActivateChecks, moduleInjector, forwardEvent) :
+                of(canDeactivate);
+        }), map(guardsResult => (Object.assign(Object.assign({}, t), { guardsResult }))));
     });
-    const parameters = res.consumed.length > 0 ? Object.assign(Object.assign({}, posParams), res.consumed[res.consumed.length - 1].parameters) :
-        posParams;
-    return {
-        matched: true,
-        consumedSegments: res.consumed,
-        remainingSegments: segments.slice(res.consumed.length),
-        // TODO(atscott): investigate combining parameters and positionalParamSegments
-        parameters,
-        positionalParamSegments: (_a = res.posParams) !== null && _a !== void 0 ? _a : {}
-    };
 }
-function split(segmentGroup, consumedSegments, slicedSegments, config, relativeLinkResolution = 'corrected') {
-    if (slicedSegments.length > 0 &&
-        containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, config)) {
-        const s = new UrlSegmentGroup(consumedSegments, createChildrenForEmptyPaths(segmentGroup, consumedSegments, config, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));
-        s._sourceSegment = segmentGroup;
-        s._segmentIndexShift = consumedSegments.length;
-        return { segmentGroup: s, slicedSegments: [] };
-    }
-    if (slicedSegments.length === 0 &&
-        containsEmptyPathMatches(segmentGroup, slicedSegments, config)) {
-        const s = new UrlSegmentGroup(segmentGroup.segments, addEmptyPathsToChildrenIfNeeded(segmentGroup, consumedSegments, slicedSegments, config, segmentGroup.children, relativeLinkResolution));
-        s._sourceSegment = segmentGroup;
-        s._segmentIndexShift = consumedSegments.length;
-        return { segmentGroup: s, slicedSegments };
-    }
-    const s = new UrlSegmentGroup(segmentGroup.segments, segmentGroup.children);
-    s._sourceSegment = segmentGroup;
-    s._segmentIndexShift = consumedSegments.length;
-    return { segmentGroup: s, slicedSegments };
+function runCanDeactivateChecks(checks, futureRSS, currRSS, moduleInjector) {
+    return from(checks).pipe(mergeMap(check => runCanDeactivate(check.component, check.route, currRSS, futureRSS, moduleInjector)), first(result => {
+        return result !== true;
+    }, true));
 }
-function addEmptyPathsToChildrenIfNeeded(segmentGroup, consumedSegments, slicedSegments, routes, children, relativeLinkResolution) {
-    const res = {};
-    for (const r of routes) {
-        if (emptyPathMatch(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {
-            const s = new UrlSegmentGroup([], {});
-            s._sourceSegment = segmentGroup;
-            if (relativeLinkResolution === 'legacy') {
-                s._segmentIndexShift = segmentGroup.segments.length;
-                if (typeof ngDevMode === 'undefined' || !!ngDevMode) {
-                    s._segmentIndexShiftCorrected = consumedSegments.length;
-                }
-            }
-            else {
-                s._segmentIndexShift = consumedSegments.length;
-            }
-            res[getOutlet(r)] = s;
-        }
+function runCanActivateChecks(futureSnapshot, checks, moduleInjector, forwardEvent) {
+    return from(checks).pipe(concatMap((check) => {
+        return concat(fireChildActivationStart(check.route.parent, forwardEvent), fireActivationStart(check.route, forwardEvent), runCanActivateChild(futureSnapshot, check.path, moduleInjector), runCanActivate(futureSnapshot, check.route, moduleInjector));
+    }), first(result => {
+        return result !== true;
+    }, true));
+}
+/**
+ * This should fire off `ActivationStart` events for each route being activated at this
+ * level.
+ * In other words, if you're activating `a` and `b` below, `path` will contain the
+ * `ActivatedRouteSnapshot`s for both and we will fire `ActivationStart` for both. Always
+ * return
+ * `true` so checks continue to run.
+ */
+function fireActivationStart(snapshot, forwardEvent) {
+    if (snapshot !== null && forwardEvent) {
+        forwardEvent(new ActivationStart(snapshot));
     }
-    return Object.assign(Object.assign({}, children), res);
+    return of(true);
 }
-function createChildrenForEmptyPaths(segmentGroup, consumedSegments, routes, primarySegment) {
-    const res = {};
-    res[PRIMARY_OUTLET] = primarySegment;
-    primarySegment._sourceSegment = segmentGroup;
-    primarySegment._segmentIndexShift = consumedSegments.length;
+/**
+ * This should fire off `ChildActivationStart` events for each route being activated at this
+ * level.
+ * In other words, if you're activating `a` and `b` below, `path` will contain the
+ * `ActivatedRouteSnapshot`s for both and we will fire `ChildActivationStart` for both. Always
+ * return
+ * `true` so checks continue to run.
+ */
+function fireChildActivationStart(snapshot, forwardEvent) {
+    if (snapshot !== null && forwardEvent) {
+        forwardEvent(new ChildActivationStart(snapshot));
+    }
+    return of(true);
+}
+function runCanActivate(futureRSS, futureARS, moduleInjector) {
+    const canActivate = futureARS.routeConfig ? futureARS.routeConfig.canActivate : null;
+    if (!canActivate || canActivate.length === 0)
+        return of(true);
+    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());
+        });
+    });
+    return of(canActivateObservables).pipe(prioritizedGuardValue());
+}
+function runCanActivateChild(futureRSS, path, moduleInjector) {
+    const futureARS = path[path.length - 1];
+    const canActivateChildGuards = path.slice(0, path.length - 1)
+        .reverse()
+        .map(p => getCanActivateChild(p))
+        .filter(_ => _ !== null);
+    const canActivateChildGuardsMapped = canActivateChildGuards.map((d) => {
+        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());
+            });
+            return of(guardsMapped).pipe(prioritizedGuardValue());
+        });
+    });
+    return of(canActivateChildGuardsMapped).pipe(prioritizedGuardValue());
+}
+function runCanDeactivate(component, currARS, currRSS, futureRSS, moduleInjector) {
+    const canDeactivate = currARS && currARS.routeConfig ? currARS.routeConfig.canDeactivate : null;
+    if (!canDeactivate || canDeactivate.length === 0)
+        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());
+    });
+    return of(canDeactivateObservables).pipe(prioritizedGuardValue());
+}
+function runCanLoadGuards(injector, route, segments, urlSerializer) {
+    const canLoad = route.canLoad;
+    if (canLoad === undefined || canLoad.length === 0) {
+        return of(true);
+    }
+    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');
+        }
+        return wrapIntoObservable(guardVal);
+    });
+    return of(canLoadObservables)
+        .pipe(prioritizedGuardValue(), redirectIfUrlTree(urlSerializer));
+}
+function redirectIfUrlTree(urlSerializer) {
+    return pipe(tap((result) => {
+        if (!isUrlTree(result))
+            return;
+        const error = navigationCancelingError(`Redirecting to "${urlSerializer.serialize(result)}"`);
+        error.url = result;
+        throw error;
+    }), map(result => result === true));
+}
+function runCanMatchGuards(injector, route, segments, urlSerializer) {
+    const canMatch = route.canMatch;
+    if (!canMatch || canMatch.length === 0)
+        return of(true);
+    const canMatchObservables = canMatch.map(injectionToken => {
+        const guard = injector.get(injectionToken);
+        const guardVal = isCanMatch(guard) ? guard.canMatch(route, segments) : guard(route, segments);
+        return wrapIntoObservable(guardVal);
+    });
+    return of(canMatchObservables)
+        .pipe(prioritizedGuardValue(), redirectIfUrlTree(urlSerializer));
+}
+
+/**
+ * @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 noMatch$1 = {
+    matched: false,
+    consumedSegments: [],
+    remainingSegments: [],
+    parameters: {},
+    positionalParamSegments: {}
+};
+function matchWithChecks(segmentGroup, route, segments, injector, urlSerializer) {
+    const result = match(segmentGroup, route, segments);
+    if (!result.matched) {
+        return of(result);
+    }
+    // Only create the Route's `EnvironmentInjector` if it matches the attempted
+    // navigation
+    injector = getOrCreateRouteInjectorIfNeeded(route, injector);
+    return runCanMatchGuards(injector, route, segments, urlSerializer)
+        .pipe(map((v) => v === true ? result : Object.assign({}, noMatch$1)));
+}
+function match(segmentGroup, route, segments) {
+    var _a;
+    if (route.path === '') {
+        if (route.pathMatch === 'full' && (segmentGroup.hasChildren() || segments.length > 0)) {
+            return Object.assign({}, noMatch$1);
+        }
+        return {
+            matched: true,
+            consumedSegments: [],
+            remainingSegments: segments,
+            parameters: {},
+            positionalParamSegments: {}
+        };
+    }
+    const matcher = route.matcher || defaultUrlMatcher;
+    const res = matcher(segments, segmentGroup, route);
+    if (!res)
+        return Object.assign({}, noMatch$1);
+    const posParams = {};
+    forEach(res.posParams, (v, k) => {
+        posParams[k] = v.path;
+    });
+    const parameters = res.consumed.length > 0 ? Object.assign(Object.assign({}, posParams), res.consumed[res.consumed.length - 1].parameters) :
+        posParams;
+    return {
+        matched: true,
+        consumedSegments: res.consumed,
+        remainingSegments: segments.slice(res.consumed.length),
+        // TODO(atscott): investigate combining parameters and positionalParamSegments
+        parameters,
+        positionalParamSegments: (_a = res.posParams) !== null && _a !== void 0 ? _a : {}
+    };
+}
+function split(segmentGroup, consumedSegments, slicedSegments, config, relativeLinkResolution = 'corrected') {
+    if (slicedSegments.length > 0 &&
+        containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, config)) {
+        const s = new UrlSegmentGroup(consumedSegments, createChildrenForEmptyPaths(segmentGroup, consumedSegments, config, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));
+        s._sourceSegment = segmentGroup;
+        s._segmentIndexShift = consumedSegments.length;
+        return { segmentGroup: s, slicedSegments: [] };
+    }
+    if (slicedSegments.length === 0 &&
+        containsEmptyPathMatches(segmentGroup, slicedSegments, config)) {
+        const s = new UrlSegmentGroup(segmentGroup.segments, addEmptyPathsToChildrenIfNeeded(segmentGroup, consumedSegments, slicedSegments, config, segmentGroup.children, relativeLinkResolution));
+        s._sourceSegment = segmentGroup;
+        s._segmentIndexShift = consumedSegments.length;
+        return { segmentGroup: s, slicedSegments };
+    }
+    const s = new UrlSegmentGroup(segmentGroup.segments, segmentGroup.children);
+    s._sourceSegment = segmentGroup;
+    s._segmentIndexShift = consumedSegments.length;
+    return { segmentGroup: s, slicedSegments };
+}
+function addEmptyPathsToChildrenIfNeeded(segmentGroup, consumedSegments, slicedSegments, routes, children, relativeLinkResolution) {
+    const res = {};
+    for (const r of routes) {
+        if (emptyPathMatch(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {
+            const s = new UrlSegmentGroup([], {});
+            s._sourceSegment = segmentGroup;
+            if (relativeLinkResolution === 'legacy') {
+                s._segmentIndexShift = segmentGroup.segments.length;
+                if (typeof ngDevMode === 'undefined' || !!ngDevMode) {
+                    s._segmentIndexShiftCorrected = consumedSegments.length;
+                }
+            }
+            else {
+                s._segmentIndexShift = consumedSegments.length;
+            }
+            res[getOutlet(r)] = s;
+        }
+    }
+    return Object.assign(Object.assign({}, children), res);
+}
+function createChildrenForEmptyPaths(segmentGroup, consumedSegments, routes, primarySegment) {
+    const res = {};
+    res[PRIMARY_OUTLET] = primarySegment;
+    primarySegment._sourceSegment = segmentGroup;
+    primarySegment._segmentIndexShift = consumedSegments.length;
     for (const r of routes) {
         if (r.path === '' && getOutlet(r) !== PRIMARY_OUTLET) {
             const s = new UrlSegmentGroup([], {});
@@ -3355,29 +3687,32 @@ class ApplyRedirects {
             }
             return of(new UrlSegmentGroup(segments, {}));
         }
-        const { matched, consumedSegments, remainingSegments } = match(rawSegmentGroup, route, segments);
-        if (!matched)
-            return noMatch(rawSegmentGroup);
-        // Only create the Route's `EnvironmentInjector` if it matches the attempted navigation
-        injector = getOrCreateRouteInjectorIfNeeded(route, injector);
-        const childConfig$ = this.getChildConfig(injector, route, segments);
-        return childConfig$.pipe(mergeMap((routerConfig) => {
+        return matchWithChecks(rawSegmentGroup, route, segments, injector, this.urlSerializer)
+            .pipe(switchMap(({ matched, consumedSegments, remainingSegments }) => {
             var _a;
-            const childInjector = (_a = routerConfig.injector) !== null && _a !== void 0 ? _a : injector;
-            const childConfig = routerConfig.routes;
-            const { segmentGroup: splitSegmentGroup, slicedSegments } = split(rawSegmentGroup, consumedSegments, remainingSegments, childConfig);
-            // See comment on the other call to `split` about why this is necessary.
-            const segmentGroup = new UrlSegmentGroup(splitSegmentGroup.segments, splitSegmentGroup.children);
-            if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
-                const expanded$ = this.expandChildren(childInjector, childConfig, segmentGroup);
-                return expanded$.pipe(map((children) => new UrlSegmentGroup(consumedSegments, children)));
-            }
-            if (childConfig.length === 0 && slicedSegments.length === 0) {
-                return of(new UrlSegmentGroup(consumedSegments, {}));
-            }
-            const matchedOnOutlet = getOutlet(route) === outlet;
-            const expanded$ = this.expandSegment(childInjector, segmentGroup, childConfig, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet, true);
-            return expanded$.pipe(map((cs) => new UrlSegmentGroup(consumedSegments.concat(cs.segments), cs.children)));
+            if (!matched)
+                return noMatch(rawSegmentGroup);
+            // If the route has an injector created from providers, we should start using that.
+            injector = (_a = route._injector) !== null && _a !== void 0 ? _a : injector;
+            const childConfig$ = this.getChildConfig(injector, route, segments);
+            return childConfig$.pipe(mergeMap((routerConfig) => {
+                var _a;
+                const childInjector = (_a = routerConfig.injector) !== null && _a !== void 0 ? _a : injector;
+                const childConfig = routerConfig.routes;
+                const { segmentGroup: splitSegmentGroup, slicedSegments } = split(rawSegmentGroup, consumedSegments, remainingSegments, childConfig);
+                // See comment on the other call to `split` about why this is necessary.
+                const segmentGroup = new UrlSegmentGroup(splitSegmentGroup.segments, splitSegmentGroup.children);
+                if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
+                    const expanded$ = this.expandChildren(childInjector, childConfig, segmentGroup);
+                    return expanded$.pipe(map((children) => new UrlSegmentGroup(consumedSegments, children)));
+                }
+                if (childConfig.length === 0 && slicedSegments.length === 0) {
+                    return of(new UrlSegmentGroup(consumedSegments, {}));
+                }
+                const matchedOnOutlet = getOutlet(route) === outlet;
+                const expanded$ = this.expandSegment(childInjector, segmentGroup, childConfig, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet, true);
+                return expanded$.pipe(map((cs) => new UrlSegmentGroup(consumedSegments.concat(cs.segments), cs.children)));
+            }));
         }));
     }
     getChildConfig(injector, route, segments) {
@@ -3390,7 +3725,7 @@ class ApplyRedirects {
             if (route._loadedRoutes !== undefined) {
                 return of({ routes: route._loadedRoutes, injector: route._loadedInjector });
             }
-            return this.runCanLoadGuards(injector, route, segments)
+            return runCanLoadGuards(injector, route, segments, this.urlSerializer)
                 .pipe(mergeMap((shouldLoadResult) => {
                 if (shouldLoadResult) {
                     return this.configLoader.loadChildren(injector, route)
@@ -3404,33 +3739,6 @@ class ApplyRedirects {
         }
         return of({ routes: [], injector });
     }
-    runCanLoadGuards(injector, route, segments) {
-        const canLoad = route.canLoad;
-        if (!canLoad || canLoad.length === 0)
-            return of(true);
-        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');
-            }
-            return wrapIntoObservable(guardVal);
-        });
-        return of(canLoadObservables)
-            .pipe(prioritizedGuardValue(), tap((result) => {
-            if (!isUrlTree(result))
-                return;
-            const error = navigationCancelingError(`Redirecting to "${this.urlSerializer.serialize(result)}"`);
-            error.url = result;
-            throw error;
-        }), map(result => result === true));
-    }
     lineralizeSegments(route, urlTree) {
         let res = [];
         let c = urlTree.root;
@@ -3443,341 +3751,58 @@ class ApplyRedirects {
                 return namedOutletsRedirect(route.redirectTo);
             }
             c = c.children[PRIMARY_OUTLET];
-        }
-    }
-    applyRedirectCommands(segments, redirectTo, posParams) {
-        return this.applyRedirectCreatreUrlTree(redirectTo, this.urlSerializer.parse(redirectTo), segments, posParams);
-    }
-    applyRedirectCreatreUrlTree(redirectTo, urlTree, segments, posParams) {
-        const newRoot = this.createSegmentGroup(redirectTo, urlTree.root, segments, posParams);
-        return new UrlTree(newRoot, this.createQueryParams(urlTree.queryParams, this.urlTree.queryParams), urlTree.fragment);
-    }
-    createQueryParams(redirectToParams, actualParams) {
-        const res = {};
-        forEach(redirectToParams, (v, k) => {
-            const copySourceValue = typeof v === 'string' && v.startsWith(':');
-            if (copySourceValue) {
-                const sourceName = v.substring(1);
-                res[k] = actualParams[sourceName];
-            }
-            else {
-                res[k] = v;
-            }
-        });
-        return res;
-    }
-    createSegmentGroup(redirectTo, group, segments, posParams) {
-        const updatedSegments = this.createSegments(redirectTo, group.segments, segments, posParams);
-        let children = {};
-        forEach(group.children, (child, name) => {
-            children[name] = this.createSegmentGroup(redirectTo, child, segments, posParams);
-        });
-        return new UrlSegmentGroup(updatedSegments, children);
-    }
-    createSegments(redirectTo, redirectToSegments, actualSegments, posParams) {
-        return redirectToSegments.map(s => s.path.startsWith(':') ? this.findPosParam(redirectTo, s, posParams) :
-            this.findOrReturn(s, actualSegments));
-    }
-    findPosParam(redirectTo, redirectToUrlSegment, posParams) {
-        const pos = posParams[redirectToUrlSegment.path.substring(1)];
-        if (!pos)
-            throw new Error(`Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);
-        return pos;
-    }
-    findOrReturn(redirectToUrlSegment, actualSegments) {
-        let idx = 0;
-        for (const s of actualSegments) {
-            if (s.path === redirectToUrlSegment.path) {
-                actualSegments.splice(idx);
-                return s;
-            }
-            idx++;
-        }
-        return redirectToUrlSegment;
-    }
-}
-
-/**
- * @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
- */
-function applyRedirects(environmentInjector, configLoader, urlSerializer, config) {
-    return switchMap(t => applyRedirects$1(environmentInjector, configLoader, urlSerializer, t.extractedUrl, config)
-        .pipe(map(urlAfterRedirects => (Object.assign(Object.assign({}, t), { urlAfterRedirects })))));
-}
-
-/**
- * @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
- */
-class CanActivate {
-    constructor(path) {
-        this.path = path;
-        this.route = this.path[this.path.length - 1];
-    }
-}
-class CanDeactivate {
-    constructor(component, route) {
-        this.component = component;
-        this.route = route;
-    }
-}
-function getAllRouteGuards(future, curr, parentContexts) {
-    const futureRoot = future._root;
-    const currRoot = curr ? curr._root : null;
-    return getChildRouteGuards(futureRoot, currRoot, parentContexts, [futureRoot.value]);
-}
-function getCanActivateChild(p) {
-    const canActivateChild = p.routeConfig ? p.routeConfig.canActivateChild : null;
-    if (!canActivateChild || canActivateChild.length === 0)
-        return null;
-    return { node: p, guards: canActivateChild };
-}
-function getToken(token, snapshot, fallbackInjector) {
-    const routeInjector = getClosestRouteInjector(snapshot);
-    const injector = routeInjector !== null && routeInjector !== void 0 ? routeInjector : fallbackInjector;
-    return injector.get(token);
-}
-function getChildRouteGuards(futureNode, currNode, contexts, futurePath, checks = {
-    canDeactivateChecks: [],
-    canActivateChecks: []
-}) {
-    const prevChildren = nodeChildrenAsMap(currNode);
-    // Process the children of the future route
-    futureNode.children.forEach(c => {
-        getRouteGuards(c, prevChildren[c.value.outlet], contexts, futurePath.concat([c.value]), checks);
-        delete prevChildren[c.value.outlet];
-    });
-    // Process any children left from the current route (not active for the future route)
-    forEach(prevChildren, (v, k) => deactivateRouteAndItsChildren(v, contexts.getContext(k), checks));
-    return checks;
-}
-function getRouteGuards(futureNode, currNode, parentContexts, futurePath, checks = {
-    canDeactivateChecks: [],
-    canActivateChecks: []
-}) {
-    const future = futureNode.value;
-    const curr = currNode ? currNode.value : null;
-    const context = parentContexts ? parentContexts.getContext(futureNode.value.outlet) : null;
-    // reusing the node
-    if (curr && future.routeConfig === curr.routeConfig) {
-        const shouldRun = shouldRunGuardsAndResolvers(curr, future, future.routeConfig.runGuardsAndResolvers);
-        if (shouldRun) {
-            checks.canActivateChecks.push(new CanActivate(futurePath));
-        }
-        else {
-            // we need to set the data
-            future.data = curr.data;
-            future._resolvedData = curr._resolvedData;
-        }
-        // If we have a component, we need to go through an outlet.
-        if (future.component) {
-            getChildRouteGuards(futureNode, currNode, context ? context.children : null, futurePath, checks);
-            // if we have a componentless route, we recurse but keep the same outlet map.
-        }
-        else {
-            getChildRouteGuards(futureNode, currNode, parentContexts, futurePath, checks);
-        }
-        if (shouldRun && context && context.outlet && context.outlet.isActivated) {
-            checks.canDeactivateChecks.push(new CanDeactivate(context.outlet.component, curr));
-        }
-    }
-    else {
-        if (curr) {
-            deactivateRouteAndItsChildren(currNode, context, checks);
-        }
-        checks.canActivateChecks.push(new CanActivate(futurePath));
-        // If we have a component, we need to go through an outlet.
-        if (future.component) {
-            getChildRouteGuards(futureNode, null, context ? context.children : null, futurePath, checks);
-            // if we have a componentless route, we recurse but keep the same outlet map.
-        }
-        else {
-            getChildRouteGuards(futureNode, null, parentContexts, futurePath, checks);
-        }
-    }
-    return checks;
-}
-function shouldRunGuardsAndResolvers(curr, future, mode) {
-    if (typeof mode === 'function') {
-        return mode(curr, future);
-    }
-    switch (mode) {
-        case 'pathParamsChange':
-            return !equalPath(curr.url, future.url);
-        case 'pathParamsOrQueryParamsChange':
-            return !equalPath(curr.url, future.url) ||
-                !shallowEqual(curr.queryParams, future.queryParams);
-        case 'always':
-            return true;
-        case 'paramsOrQueryParamsChange':
-            return !equalParamsAndUrlSegments(curr, future) ||
-                !shallowEqual(curr.queryParams, future.queryParams);
-        case 'paramsChange':
-        default:
-            return !equalParamsAndUrlSegments(curr, future);
-    }
-}
-function deactivateRouteAndItsChildren(route, context, checks) {
-    const children = nodeChildrenAsMap(route);
-    const r = route.value;
-    forEach(children, (node, childName) => {
-        if (!r.component) {
-            deactivateRouteAndItsChildren(node, context, checks);
-        }
-        else if (context) {
-            deactivateRouteAndItsChildren(node, context.children.getContext(childName), checks);
-        }
-        else {
-            deactivateRouteAndItsChildren(node, null, checks);
-        }
-    });
-    if (!r.component) {
-        checks.canDeactivateChecks.push(new CanDeactivate(null, r));
-    }
-    else if (context && context.outlet && context.outlet.isActivated) {
-        checks.canDeactivateChecks.push(new CanDeactivate(context.outlet.component, r));
-    }
-    else {
-        checks.canDeactivateChecks.push(new CanDeactivate(null, r));
-    }
-}
-
-/**
- * @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
- */
-function checkGuards(moduleInjector, forwardEvent) {
-    return mergeMap(t => {
-        const { targetSnapshot, currentSnapshot, guards: { canActivateChecks, canDeactivateChecks } } = t;
-        if (canDeactivateChecks.length === 0 && canActivateChecks.length === 0) {
-            return of(Object.assign(Object.assign({}, t), { guardsResult: true }));
-        }
-        return runCanDeactivateChecks(canDeactivateChecks, targetSnapshot, currentSnapshot, moduleInjector)
-            .pipe(mergeMap(canDeactivate => {
-            return canDeactivate && isBoolean(canDeactivate) ?
-                runCanActivateChecks(targetSnapshot, canActivateChecks, moduleInjector, forwardEvent) :
-                of(canDeactivate);
-        }), map(guardsResult => (Object.assign(Object.assign({}, t), { guardsResult }))));
-    });
-}
-function runCanDeactivateChecks(checks, futureRSS, currRSS, moduleInjector) {
-    return from(checks).pipe(mergeMap(check => runCanDeactivate(check.component, check.route, currRSS, futureRSS, moduleInjector)), first(result => {
-        return result !== true;
-    }, true));
-}
-function runCanActivateChecks(futureSnapshot, checks, moduleInjector, forwardEvent) {
-    return from(checks).pipe(concatMap((check) => {
-        return concat(fireChildActivationStart(check.route.parent, forwardEvent), fireActivationStart(check.route, forwardEvent), runCanActivateChild(futureSnapshot, check.path, moduleInjector), runCanActivate(futureSnapshot, check.route, moduleInjector));
-    }), first(result => {
-        return result !== true;
-    }, true));
-}
-/**
- * This should fire off `ActivationStart` events for each route being activated at this
- * level.
- * In other words, if you're activating `a` and `b` below, `path` will contain the
- * `ActivatedRouteSnapshot`s for both and we will fire `ActivationStart` for both. Always
- * return
- * `true` so checks continue to run.
- */
-function fireActivationStart(snapshot, forwardEvent) {
-    if (snapshot !== null && forwardEvent) {
-        forwardEvent(new ActivationStart(snapshot));
-    }
-    return of(true);
-}
-/**
- * This should fire off `ChildActivationStart` events for each route being activated at this
- * level.
- * In other words, if you're activating `a` and `b` below, `path` will contain the
- * `ActivatedRouteSnapshot`s for both and we will fire `ChildActivationStart` for both. Always
- * return
- * `true` so checks continue to run.
- */
-function fireChildActivationStart(snapshot, forwardEvent) {
-    if (snapshot !== null && forwardEvent) {
-        forwardEvent(new ChildActivationStart(snapshot));
-    }
-    return of(true);
-}
-function runCanActivate(futureRSS, futureARS, moduleInjector) {
-    const canActivate = futureARS.routeConfig ? futureARS.routeConfig.canActivate : null;
-    if (!canActivate || canActivate.length === 0)
-        return of(true);
-    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));
+        }
+    }
+    applyRedirectCommands(segments, redirectTo, posParams) {
+        return this.applyRedirectCreatreUrlTree(redirectTo, this.urlSerializer.parse(redirectTo), segments, posParams);
+    }
+    applyRedirectCreatreUrlTree(redirectTo, urlTree, segments, posParams) {
+        const newRoot = this.createSegmentGroup(redirectTo, urlTree.root, segments, posParams);
+        return new UrlTree(newRoot, this.createQueryParams(urlTree.queryParams, this.urlTree.queryParams), urlTree.fragment);
+    }
+    createQueryParams(redirectToParams, actualParams) {
+        const res = {};
+        forEach(redirectToParams, (v, k) => {
+            const copySourceValue = typeof v === 'string' && v.startsWith(':');
+            if (copySourceValue) {
+                const sourceName = v.substring(1);
+                res[k] = actualParams[sourceName];
             }
             else {
-                throw new Error('Invalid CanActivate guard');
+                res[k] = v;
             }
-            return observable.pipe(first());
         });
-    });
-    return of(canActivateObservables).pipe(prioritizedGuardValue());
-}
-function runCanActivateChild(futureRSS, path, moduleInjector) {
-    const futureARS = path[path.length - 1];
-    const canActivateChildGuards = path.slice(0, path.length - 1)
-        .reverse()
-        .map(p => getCanActivateChild(p))
-        .filter(_ => _ !== null);
-    const canActivateChildGuardsMapped = canActivateChildGuards.map((d) => {
-        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());
-            });
-            return of(guardsMapped).pipe(prioritizedGuardValue());
+        return res;
+    }
+    createSegmentGroup(redirectTo, group, segments, posParams) {
+        const updatedSegments = this.createSegments(redirectTo, group.segments, segments, posParams);
+        let children = {};
+        forEach(group.children, (child, name) => {
+            children[name] = this.createSegmentGroup(redirectTo, child, segments, posParams);
         });
-    });
-    return of(canActivateChildGuardsMapped).pipe(prioritizedGuardValue());
-}
-function runCanDeactivate(component, currARS, currRSS, futureRSS, moduleInjector) {
-    const canDeactivate = currARS && currARS.routeConfig ? currARS.routeConfig.canDeactivate : null;
-    if (!canDeactivate || canDeactivate.length === 0)
-        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 new UrlSegmentGroup(updatedSegments, children);
+    }
+    createSegments(redirectTo, redirectToSegments, actualSegments, posParams) {
+        return redirectToSegments.map(s => s.path.startsWith(':') ? this.findPosParam(redirectTo, s, posParams) :
+            this.findOrReturn(s, actualSegments));
+    }
+    findPosParam(redirectTo, redirectToUrlSegment, posParams) {
+        const pos = posParams[redirectToUrlSegment.path.substring(1)];
+        if (!pos)
+            throw new Error(`Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);
+        return pos;
+    }
+    findOrReturn(redirectToUrlSegment, actualSegments) {
+        let idx = 0;
+        for (const s of actualSegments) {
+            if (s.path === redirectToUrlSegment.path) {
+                actualSegments.splice(idx);
+                return s;
+            }
+            idx++;
         }
-        return observable.pipe(first());
-    });
-    return of(canDeactivateObservables).pipe(prioritizedGuardValue());
+        return redirectToUrlSegment;
+    }
 }
 
 /**
@@ -3787,53 +3812,64 @@ function runCanDeactivate(component, currARS, currRSS, futureRSS, moduleInjector
  * 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 applyRedirects(environmentInjector, configLoader, urlSerializer, config) {
+    return switchMap(t => applyRedirects$1(environmentInjector, configLoader, urlSerializer, t.extractedUrl, config)
+        .pipe(map(urlAfterRedirects => (Object.assign(Object.assign({}, t), { urlAfterRedirects })))));
+}
+
+/**
+ * @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;
 class NoMatch {
 }
 function newObservableError(e) {
     // TODO(atscott): This pattern is used throughout the router code and can be `throwError` instead.
     return new Observable((obs) => obs.error(e));
 }
-function recognize$1(rootComponentType, config, urlTree, url, paramsInheritanceStrategy = 'emptyOnly', relativeLinkResolution = 'legacy') {
-    try {
-        const result = new Recognizer(rootComponentType, config, urlTree, url, paramsInheritanceStrategy, relativeLinkResolution)
-            .recognize();
+function recognize$1(injector, rootComponentType, config, urlTree, url, urlSerializer, paramsInheritanceStrategy = 'emptyOnly', relativeLinkResolution = 'legacy') {
+    return new Recognizer(injector, rootComponentType, config, urlTree, url, paramsInheritanceStrategy, relativeLinkResolution, urlSerializer)
+        .recognize()
+        .pipe(switchMap(result => {
         if (result === null) {
             return newObservableError(new NoMatch());
         }
         else {
             return of(result);
         }
-    }
-    catch (e) {
-        // Catch the potential error from recognize due to duplicate outlet matches and return as an
-        // `Observable` error instead.
-        return newObservableError(e);
-    }
+    }));
 }
 class Recognizer {
-    constructor(rootComponentType, config, urlTree, url, paramsInheritanceStrategy, relativeLinkResolution) {
+    constructor(injector, rootComponentType, config, urlTree, url, paramsInheritanceStrategy, relativeLinkResolution, urlSerializer) {
+        this.injector = injector;
         this.rootComponentType = rootComponentType;
         this.config = config;
         this.urlTree = urlTree;
         this.url = url;
         this.paramsInheritanceStrategy = paramsInheritanceStrategy;
         this.relativeLinkResolution = relativeLinkResolution;
+        this.urlSerializer = urlSerializer;
     }
     recognize() {
         const rootSegmentGroup = split(this.urlTree.root, [], [], this.config.filter(c => c.redirectTo === undefined), this.relativeLinkResolution)
             .segmentGroup;
-        const children = this.processSegmentGroup(this.config, rootSegmentGroup, PRIMARY_OUTLET);
-        if (children === null) {
-            return null;
-        }
-        // Use Object.freeze to prevent readers of the Router state from modifying it outside of a
-        // navigation, resulting in the router being out of sync with the browser.
-        const root = new ActivatedRouteSnapshot([], Object.freeze({}), Object.freeze(Object.assign({}, this.urlTree.queryParams)), this.urlTree.fragment, {}, PRIMARY_OUTLET, this.rootComponentType, null, this.urlTree.root, -1, {});
-        const rootNode = new TreeNode(root, children);
-        const routeState = new RouterStateSnapshot(this.url, rootNode);
-        this.inheritParamsAndData(routeState._root);
-        return routeState;
+        return this.processSegmentGroup(this.injector, this.config, rootSegmentGroup, PRIMARY_OUTLET)
+            .pipe(map(children => {
+            if (children === null) {
+                return null;
+            }
+            // Use Object.freeze to prevent readers of the Router state from modifying it outside of a
+            // navigation, resulting in the router being out of sync with the browser.
+            const root = new ActivatedRouteSnapshot([], Object.freeze({}), Object.freeze(Object.assign({}, this.urlTree.queryParams)), this.urlTree.fragment, {}, PRIMARY_OUTLET, this.rootComponentType, null, this.urlTree.root, -1, {});
+            const rootNode = new TreeNode(root, children);
+            const routeState = new RouterStateSnapshot(this.url, rootNode);
+            this.inheritParamsAndData(routeState._root);
+            return routeState;
+        }));
     }
     inheritParamsAndData(routeNode) {
         const route = routeNode.value;
@@ -3842,11 +3878,11 @@ class Recognizer {
         route.data = Object.freeze(i.data);
         routeNode.children.forEach(n => this.inheritParamsAndData(n));
     }
-    processSegmentGroup(config, segmentGroup, outlet) {
+    processSegmentGroup(injector, config, segmentGroup, outlet) {
         if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
-            return this.processChildren(config, segmentGroup);
+            return this.processChildren(injector, config, segmentGroup);
         }
-        return this.processSegment(config, segmentGroup, segmentGroup.segments, outlet);
+        return this.processSegment(injector, config, segmentGroup, segmentGroup.segments, outlet);
     }
     /**
      * Matches every child outlet in the `segmentGroup` to a `Route` in the config. Returns `null` if
@@ -3856,103 +3892,129 @@ class Recognizer {
      * @param segmentGroup - The `UrlSegmentGroup` whose children need to be matched against the
      *     config.
      */
-    processChildren(config, segmentGroup) {
-        const children = [];
-        for (const childOutlet of Object.keys(segmentGroup.children)) {
+    processChildren(injector, config, segmentGroup) {
+        return from(Object.keys(segmentGroup.children))
+            .pipe(concatMap(childOutlet => {
             const child = segmentGroup.children[childOutlet];
-            // Sort the config so that routes with outlets that match the one being activated appear
-            // first, followed by routes for other outlets, which might match if they have an empty path.
+            // Sort the config so that routes with outlets that match the one being activated
+            // appear first, followed by routes for other outlets, which might match if they have
+            // an empty path.
             const sortedConfig = sortByMatchingOutlets(config, childOutlet);
-            const outletChildren = this.processSegmentGroup(sortedConfig, child, childOutlet);
-            if (outletChildren === null) {
-                // Configs must match all segment children so because we did not find a match for this
-                // outlet, return `null`.
+            return this.processSegmentGroup(injector, sortedConfig, child, childOutlet);
+        }), scan((children, outletChildren) => {
+            if (!children || !outletChildren)
                 return null;
-            }
             children.push(...outletChildren);
-        }
-        // Because we may have matched two outlets to the same empty path segment, we can have multiple
-        // activated results for the same outlet. We should merge the children of these results so the
-        // final return value is only one `TreeNode` per outlet.
-        const mergedChildren = mergeEmptyPathMatches(children);
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            // This should really never happen - we are only taking the first match for each outlet and
-            // merge the empty path matches.
-            checkOutletNameUniqueness(mergedChildren);
-        }
-        sortActivatedRouteSnapshots(mergedChildren);
-        return mergedChildren;
-    }
-    processSegment(config, segmentGroup, segments, outlet) {
-        for (const r of config) {
-            const children = this.processSegmentAgainstRoute(r, segmentGroup, segments, outlet);
-            if (children !== null) {
-                return children;
+            return children;
+        }), takeWhile(children => children !== null), defaultIfEmpty(null), last$1(), map(children => {
+            if (children === null)
+                return null;
+            // Because we may have matched two outlets to the same empty path segment, we can have
+            // multiple activated results for the same outlet. We should merge the children of
+            // these results so the final return value is only one `TreeNode` per outlet.
+            const mergedChildren = mergeEmptyPathMatches(children);
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                // This should really never happen - we are only taking the first match for each
+                // outlet and merge the empty path matches.
+                checkOutletNameUniqueness(mergedChildren);
             }
-        }
-        if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
-            return [];
-        }
-        return null;
+            sortActivatedRouteSnapshots(mergedChildren);
+            return mergedChildren;
+        }));
+    }
+    processSegment(injector, routes, segmentGroup, segments, outlet) {
+        return from(routes).pipe(concatMap(r => {
+            var _a;
+            return this.processSegmentAgainstRoute((_a = r._injector) !== null && _a !== void 0 ? _a : injector, r, segmentGroup, segments, outlet);
+        }), first((x) => !!x), catchError(e => {
+            if (e instanceof EmptyError) {
+                if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
+                    return of([]);
+                }
+                return of(null);
+            }
+            throw e;
+        }));
     }
-    processSegmentAgainstRoute(route, rawSegment, segments, outlet) {
-        var _a, _b, _c, _d;
+    processSegmentAgainstRoute(injector, route, rawSegment, segments, outlet) {
+        var _a, _b;
         if (route.redirectTo || !isImmediateMatch(route, rawSegment, segments, outlet))
-            return null;
-        let snapshot;
-        let consumedSegments = [];
-        let remainingSegments = [];
+            return of(null);
+        let matchResult;
         if (route.path === '**') {
             const params = segments.length > 0 ? last(segments).parameters : {};
             const pathIndexShift = getPathIndexShift(rawSegment) + segments.length;
-            snapshot = new ActivatedRouteSnapshot(segments, params, Object.freeze(Object.assign({}, this.urlTree.queryParams)), this.urlTree.fragment, getData(route), getOutlet(route), (_b = (_a = route.component) !== null && _a !== void 0 ? _a : route._loadedComponent) !== null && _b !== void 0 ? _b : null, route, getSourceSegmentGroup(rawSegment), pathIndexShift, getResolve(route), 
+            const snapshot = new ActivatedRouteSnapshot(segments, params, Object.freeze(Object.assign({}, this.urlTree.queryParams)), this.urlTree.fragment, getData(route), getOutlet(route), (_b = (_a = route.component) !== null && _a !== void 0 ? _a : route._loadedComponent) !== null && _b !== void 0 ? _b : null, route, getSourceSegmentGroup(rawSegment), pathIndexShift, getResolve(route), 
             // NG_DEV_MODE is used to prevent the getCorrectedPathIndexShift function from affecting
             // production bundle size. This value is intended only to surface a warning to users
             // depending on `relativeLinkResolution: 'legacy'` in dev mode.
-            (NG_DEV_MODE$2 ? getCorrectedPathIndexShift(rawSegment) + segments.length :
+            (NG_DEV_MODE$3 ? getCorrectedPathIndexShift(rawSegment) + segments.length :
                 pathIndexShift));
+            matchResult = of({
+                snapshot,
+                consumedSegments: [],
+                remainingSegments: [],
+            });
         }
         else {
-            const result = match(rawSegment, route, segments);
-            if (!result.matched) {
-                return null;
-            }
-            consumedSegments = result.consumedSegments;
-            remainingSegments = result.remainingSegments;
-            const pathIndexShift = getPathIndexShift(rawSegment) + consumedSegments.length;
-            snapshot = new ActivatedRouteSnapshot(consumedSegments, result.parameters, Object.freeze(Object.assign({}, this.urlTree.queryParams)), this.urlTree.fragment, getData(route), getOutlet(route), (_d = (_c = route.component) !== null && _c !== void 0 ? _c : route._loadedComponent) !== null && _d !== void 0 ? _d : null, route, getSourceSegmentGroup(rawSegment), pathIndexShift, getResolve(route), (NG_DEV_MODE$2 ? getCorrectedPathIndexShift(rawSegment) + consumedSegments.length :
-                pathIndexShift));
+            matchResult =
+                matchWithChecks(rawSegment, route, segments, injector, this.urlSerializer)
+                    .pipe(map(({ matched, consumedSegments, remainingSegments, parameters }) => {
+                    var _a, _b;
+                    if (!matched) {
+                        return null;
+                    }
+                    const pathIndexShift = getPathIndexShift(rawSegment) + consumedSegments.length;
+                    const snapshot = new ActivatedRouteSnapshot(consumedSegments, parameters, Object.freeze(Object.assign({}, this.urlTree.queryParams)), this.urlTree.fragment, getData(route), getOutlet(route), (_b = (_a = route.component) !== null && _a !== void 0 ? _a : route._loadedComponent) !== null && _b !== void 0 ? _b : null, route, getSourceSegmentGroup(rawSegment), pathIndexShift, getResolve(route), (NG_DEV_MODE$3 ?
+                        getCorrectedPathIndexShift(rawSegment) + consumedSegments.length :
+                        pathIndexShift));
+                    return { snapshot, consumedSegments, remainingSegments };
+                }));
         }
-        const childConfig = getChildConfig(route);
-        const { segmentGroup, slicedSegments } = split(rawSegment, consumedSegments, remainingSegments, 
-        // Filter out routes with redirectTo because we are trying to create activated route
-        // snapshots and don't handle redirects here. That should have been done in
-        // `applyRedirects`.
-        childConfig.filter(c => c.redirectTo === undefined), this.relativeLinkResolution);
-        if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
-            const children = this.processChildren(childConfig, segmentGroup);
-            if (children === null) {
-                return null;
+        return matchResult.pipe(switchMap((result) => {
+            var _a, _b;
+            if (result === null) {
+                return of(null);
             }
-            return [new TreeNode(snapshot, children)];
-        }
-        if (childConfig.length === 0 && slicedSegments.length === 0) {
-            return [new TreeNode(snapshot, [])];
-        }
-        const matchedOnOutlet = getOutlet(route) === outlet;
-        // If we matched a config due to empty path match on a different outlet, we need to continue
-        // passing the current outlet for the segment rather than switch to PRIMARY.
-        // Note that we switch to primary when we have a match because outlet configs look like this:
-        // {path: 'a', outlet: 'a', children: [
-        //  {path: 'b', component: B},
-        //  {path: 'c', component: C},
-        // ]}
-        // Notice that the children of the named outlet are configured with the primary outlet
-        const children = this.processSegment(childConfig, segmentGroup, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet);
-        if (children === null) {
-            return null;
-        }
-        return [new TreeNode(snapshot, children)];
+            const { snapshot, consumedSegments, remainingSegments } = result;
+            // If the route has an injector created from providers, we should start using that.
+            injector = (_a = route._injector) !== null && _a !== void 0 ? _a : injector;
+            const childInjector = (_b = route._loadedInjector) !== null && _b !== void 0 ? _b : injector;
+            const childConfig = getChildConfig(route);
+            const { segmentGroup, slicedSegments } = split(rawSegment, consumedSegments, remainingSegments, 
+            // Filter out routes with redirectTo because we are trying to create activated route
+            // snapshots and don't handle redirects here. That should have been done in
+            // `applyRedirects`.
+            childConfig.filter(c => c.redirectTo === undefined), this.relativeLinkResolution);
+            if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
+                return this.processChildren(childInjector, childConfig, segmentGroup).pipe(map(children => {
+                    if (children === null) {
+                        return null;
+                    }
+                    return [new TreeNode(snapshot, children)];
+                }));
+            }
+            if (childConfig.length === 0 && slicedSegments.length === 0) {
+                return of([new TreeNode(snapshot, [])]);
+            }
+            const matchedOnOutlet = getOutlet(route) === outlet;
+            // If we matched a config due to empty path match on a different outlet, we need to
+            // continue passing the current outlet for the segment rather than switch to PRIMARY.
+            // Note that we switch to primary when we have a match because outlet configs look like
+            // this: {path: 'a', outlet: 'a', children: [
+            //  {path: 'b', component: B},
+            //  {path: 'c', component: C},
+            // ]}
+            // Notice that the children of the named outlet are configured with the primary outlet
+            return this
+                .processSegment(childInjector, childConfig, segmentGroup, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet)
+                .pipe(map(children => {
+                if (children === null) {
+                    return null;
+                }
+                return [new TreeNode(snapshot, children)];
+            }));
+        }));
     }
 }
 function sortActivatedRouteSnapshots(nodes) {
@@ -3978,9 +4040,9 @@ function hasEmptyPathConfig(node) {
     return config && config.path === '' && config.redirectTo === undefined;
 }
 /**
- * Finds `TreeNode`s with matching empty path route configs and merges them into `TreeNode` with the
- * children from each duplicate. This is necessary because different outlets can match a single
- * empty path route config and the results need to then be merged.
+ * Finds `TreeNode`s with matching empty path route configs and merges them into `TreeNode` with
+ * the children from each duplicate. This is necessary because different outlets can match a
+ * single empty path route config and the results need to then be merged.
  */
 function mergeEmptyPathMatches(nodes) {
     const result = [];
@@ -4001,9 +4063,9 @@ function mergeEmptyPathMatches(nodes) {
         }
     }
     // For each node which has children from multiple sources, we need to recompute a new `TreeNode`
-    // by also merging those children. This is necessary when there are multiple empty path configs in
-    // a row. Put another way: whenever we combine children of two nodes, we need to also check if any
-    // of those children can be combined into a single node as well.
+    // by also merging those children. This is necessary when there are multiple empty path configs
+    // in a row. Put another way: whenever we combine children of two nodes, we need to also check
+    // if any of those children can be combined into a single node as well.
     for (const mergedNode of mergedNodes) {
         const mergedChildren = mergeEmptyPathMatches(mergedNode.children);
         result.push(new TreeNode(mergedNode.value, mergedChildren));
@@ -4063,8 +4125,8 @@ function getResolve(route) {
  * 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
  */
-function recognize(rootComponentType, config, serializer, paramsInheritanceStrategy, relativeLinkResolution) {
-    return mergeMap(t => recognize$1(rootComponentType, config, t.urlAfterRedirects, serializer(t.urlAfterRedirects), paramsInheritanceStrategy, relativeLinkResolution)
+function recognize(injector, rootComponentType, config, serializer, paramsInheritanceStrategy, relativeLinkResolution) {
+    return mergeMap(t => recognize$1(injector, rootComponentType, config, t.urlAfterRedirects, serializer.serialize(t.urlAfterRedirects), serializer, paramsInheritanceStrategy, relativeLinkResolution)
         .pipe(map(targetSnapshot => (Object.assign(Object.assign({}, t), { targetSnapshot })))));
 }
 
@@ -4226,7 +4288,7 @@ class DefaultRouteReuseStrategy extends BaseRouteReuseStrategy {
  * 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$1 = typeof ngDevMode === 'undefined' || !!ngDevMode;
+const NG_DEV_MODE$2 = typeof ngDevMode === 'undefined' || !!ngDevMode;
 /**
  * The [DI token](guide/glossary/#di-token) for a router configuration.
  *
@@ -4261,7 +4323,7 @@ class RouterConfigLoader {
             if (this.onLoadEndListener) {
                 this.onLoadEndListener(route);
             }
-            NG_DEV_MODE$1 && assertStandalone((_a = route.path) !== null && _a !== void 0 ? _a : '', component);
+            NG_DEV_MODE$2 && assertStandalone((_a = route.path) !== null && _a !== void 0 ? _a : '', component);
             route._loadedComponent = component;
         }), finalize(() => {
             this.componentLoaders.delete(route);
@@ -4304,7 +4366,7 @@ class RouterConfigLoader {
                 rawRoutes = flatten(injector.get(ROUTES, [], InjectFlags.Self | InjectFlags.Optional));
             }
             const routes = rawRoutes.map(standardizeConfig);
-            NG_DEV_MODE$1 && validateConfig(routes, route.path, requireStandaloneComponents);
+            NG_DEV_MODE$2 && validateConfig(routes, route.path, requireStandaloneComponents);
             return { routes, injector };
         }), finalize(() => {
             this.childrenLoaders.delete(route);
@@ -4326,9 +4388,9 @@ class RouterConfigLoader {
         }));
     }
 }
-RouterConfigLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.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-next.0", ngImport: i0, type: RouterConfigLoader });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterConfigLoader, decorators: [{
+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: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.Compiler }]; } });
 
@@ -4363,19 +4425,13 @@ class DefaultUrlHandlingStrategy {
     }
 }
 
-const NG_DEV_MODE = typeof ngDevMode === 'undefined' || !!ngDevMode;
+const NG_DEV_MODE$1 = typeof ngDevMode === 'undefined' || !!ngDevMode;
 function defaultErrorHandler(error) {
     throw error;
 }
 function defaultMalformedUriErrorHandler(error, urlSerializer, url) {
     return urlSerializer.parse('/');
 }
-/**
- * @internal
- */
-function defaultRouterHook(snapshot, runExtras) {
-    return of(null);
-}
 /**
  * The equivalent `IsActiveMatchOptions` options for `Router.isActive` is called with `true`
  * (exact = true).
@@ -4455,13 +4511,12 @@ class Router {
         this.navigated = false;
         this.lastSuccessfulId = -1;
         /**
-         * Hooks that enable you to pause navigation,
-         * either before or after the preactivation phase.
+         * Hook that enables you to pause navigation after the preactivation phase.
          * Used by `RouterModule`.
          *
          * @internal
          */
-        this.hooks = { beforePreactivation: defaultRouterHook, afterPreactivation: defaultRouterHook };
+        this.afterPreactivation = () => of(void 0);
         /**
          * A strategy for extracting and merging URLs.
          * Used for AngularJS to Angular migrations.
@@ -4638,7 +4693,7 @@ class Router {
                         this.currentNavigation = Object.assign(Object.assign({}, this.currentNavigation), { finalUrl: t.urlAfterRedirects });
                     }), 
                     // Recognize
-                    recognize(this.rootComponentType, this.config, (url) => this.serializeUrl(url), this.paramsInheritanceStrategy, this.relativeLinkResolution), 
+                    recognize(this.ngModule.injector, this.rootComponentType, this.config, this.urlSerializer, this.paramsInheritanceStrategy, this.relativeLinkResolution), 
                     // Update URL if in `eager` update mode
                     tap(t => {
                         if (this.urlUpdateStrategy === 'eager') {
@@ -4678,17 +4733,6 @@ class Router {
                     }
                 }
             }), 
-            // Before Preactivation
-            switchTap(t => {
-                const { targetSnapshot, id: navigationId, extractedUrl: appliedUrlTree, rawUrl: rawUrlTree, extras: { skipLocationChange, replaceUrl } } = t;
-                return this.hooks.beforePreactivation(targetSnapshot, {
-                    navigationId,
-                    appliedUrlTree,
-                    rawUrlTree,
-                    skipLocationChange: !!skipLocationChange,
-                    replaceUrl: !!replaceUrl,
-                });
-            }), 
             // --- GUARDS ---
             tap(t => {
                 const guardsStart = new GuardsCheckStart(t.id, this.serializeUrl(t.extractedUrl), this.serializeUrl(t.urlAfterRedirects), t.targetSnapshot);
@@ -4732,18 +4776,7 @@ class Router {
                     }));
                 }
                 return undefined;
-            }), 
-            // --- AFTER PREACTIVATION ---
-            switchTap((t) => {
-                const { targetSnapshot, id: navigationId, extractedUrl: appliedUrlTree, rawUrl: rawUrlTree, extras: { skipLocationChange, replaceUrl } } = t;
-                return this.hooks.afterPreactivation(targetSnapshot, {
-                    navigationId,
-                    appliedUrlTree,
-                    rawUrlTree,
-                    skipLocationChange: !!skipLocationChange,
-                    replaceUrl: !!replaceUrl,
-                });
-            }), 
+            }), switchTap(() => this.afterPreactivation()), 
             // --- LOAD COMPONENTS ---
             switchTap((t) => {
                 const loadComponents = (route) => {
@@ -4963,7 +4996,7 @@ class Router {
      * ```
      */
     resetConfig(config) {
-        NG_DEV_MODE && validateConfig(config);
+        NG_DEV_MODE$1 && validateConfig(config);
         this.config = config.map(standardizeConfig);
         this.navigated = false;
         this.lastSuccessfulId = -1;
@@ -5321,9 +5354,9 @@ class Router {
         return { navigationId };
     }
 }
-Router.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: Router, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
-Router.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: Router });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: Router, decorators: [{
+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: [{
             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) {
@@ -5515,9 +5548,9 @@ class RouterLink {
         });
     }
 }
-RouterLink.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.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-next.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-next.0", ngImport: i0, type: RouterLink, decorators: [{
+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: [{
             type: Directive,
             args: [{ selector: ':not(a):not(area)[routerLink]' }]
         }], ctorParameters: function () {
@@ -5636,9 +5669,9 @@ class RouterLinkWithHref {
         });
     }
 }
-RouterLinkWithHref.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.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-next.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-next.0", ngImport: i0, type: RouterLinkWithHref, decorators: [{
+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: [{
             type: Directive,
             args: [{ selector: 'a[routerLink],area[routerLink]' }]
         }], ctorParameters: function () { return [{ type: Router }, { type: ActivatedRoute }, { type: i3.LocationStrategy }]; }, propDecorators: { target: [{
@@ -5865,9 +5898,9 @@ class RouterLinkActive {
             this.links.some(isActiveCheckFn) || this.linksWithHrefs.some(isActiveCheckFn);
     }
 }
-RouterLinkActive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.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-next.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-next.0", ngImport: i0, type: RouterLinkActive, decorators: [{
+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: [{
             type: Directive,
             args: [{
                     selector: '[routerLinkActive]',
@@ -5973,9 +6006,9 @@ class DefaultTitleStrategy extends TitleStrategy {
         }
     }
 }
-DefaultTitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.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-next.0", ngImport: i0, type: DefaultTitleStrategy, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: DefaultTitleStrategy, decorators: [{
+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: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i1.Title }]; } });
@@ -6012,6 +6045,12 @@ 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: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 /**
  * @description
  *
@@ -6026,6 +6065,12 @@ 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: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 /**
  * The preloader optimistically loads all router configurations to
  * make navigations into lazily-loaded sections of the application faster.
@@ -6110,12 +6155,13 @@ class RouterPreloader {
         });
     }
 }
-RouterPreloader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.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-next.0", ngImport: i0, type: RouterPreloader });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterPreloader, decorators: [{
+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: [{
             type: Injectable
         }], 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, options = {}) {
@@ -6191,9 +6237,9 @@ class RouterScroller {
         }
     }
 }
-RouterScroller.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
-RouterScroller.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterScroller });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterScroller, decorators: [{
+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: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: Router }, { type: i3.ViewportScroller }, { type: undefined }]; } });
 
@@ -6204,6 +6250,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0",
  * 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 = typeof ngDevMode === 'undefined' || ngDevMode;
 /**
  * The directives defined in the `RouterModule`.
  */
@@ -6213,11 +6260,15 @@ const ROUTER_DIRECTIVES = [RouterOutlet, RouterLink, RouterLinkWithHref, RouterL
  *
  * @publicApi
  */
-const ROUTER_CONFIGURATION = new InjectionToken('ROUTER_CONFIGURATION');
+const ROUTER_CONFIGURATION = new InjectionToken(NG_DEV_MODE ? 'router config' : 'ROUTER_CONFIGURATION', {
+    providedIn: 'root',
+    factory: () => ({}),
+});
 /**
  * @docsNotRequired
  */
-const ROUTER_FORROOT_GUARD = new InjectionToken('ROUTER_FORROOT_GUARD');
+const ROUTER_FORROOT_GUARD = new InjectionToken(NG_DEV_MODE ? 'router duplicate forRoot guard' : 'ROUTER_FORROOT_GUARD');
+const ROUTER_PRELOADER = new InjectionToken(NG_DEV_MODE ? 'router preloader' : '');
 const ROUTER_PROVIDERS = [
     Location,
     { provide: UrlSerializer, useClass: DefaultUrlSerializer },
@@ -6232,10 +6283,6 @@ const ROUTER_PROVIDERS = [
     },
     ChildrenOutletContexts,
     { provide: ActivatedRoute, useFactory: rootRoute, deps: [Router] },
-    RouterPreloader,
-    NoPreloading,
-    PreloadAllModules,
-    { provide: ROUTER_CONFIGURATION, useValue: { enableTracing: false } },
     RouterConfigLoader,
 ];
 function routerNgProbeToken() {
@@ -6288,6 +6335,7 @@ class RouterModule {
             ngModule: RouterModule,
             providers: [
                 ROUTER_PROVIDERS,
+                NG_DEV_MODE ? ((config === null || config === void 0 ? void 0 : config.enableTracing) ? provideTracing() : []) : [],
                 provideRoutes(routes),
                 {
                     provide: ROUTER_FORROOT_GUARD,
@@ -6295,22 +6343,11 @@ class RouterModule {
                     deps: [[Router, new Optional(), new SkipSelf()]]
                 },
                 { provide: ROUTER_CONFIGURATION, useValue: config ? config : {} },
-                {
-                    provide: LocationStrategy,
-                    useFactory: provideLocationStrategy,
-                    deps: [PlatformLocation, [new Inject(APP_BASE_HREF), new Optional()], ROUTER_CONFIGURATION]
-                },
-                {
-                    provide: RouterScroller,
-                    useFactory: createRouterScroller,
-                    deps: [Router, ViewportScroller, ROUTER_CONFIGURATION]
-                },
-                {
-                    provide: PreloadingStrategy,
-                    useExisting: config && config.preloadingStrategy ? config.preloadingStrategy :
-                        NoPreloading
-                },
+                (config === null || config === void 0 ? void 0 : config.useHash) ? provideHashLocationStrategy() : providePathLocationStrategy(),
+                provideRouterScroller(),
+                (config === null || config === void 0 ? void 0 : config.preloadingStrategy) ? providePreloading(config.preloadingStrategy) : [],
                 { provide: NgProbeToken, multi: true, useFactory: routerNgProbeToken },
+                (config === null || config === void 0 ? void 0 : config.initialNavigation) ? provideInitialNavigation(config) : [],
                 provideRouterInitializer(),
             ],
         };
@@ -6335,10 +6372,10 @@ class RouterModule {
         return { ngModule: RouterModule, providers: [provideRoutes(routes)] };
     }
 }
-RouterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.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-next.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-next.0", ngImport: i0, type: RouterModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterModule, decorators: [{
+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: [{
             type: NgModule,
             args: [{
                     declarations: ROUTER_DIRECTIVES,
@@ -6354,18 +6391,28 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0",
                         type: Optional
                     }] }];
     } });
-function createRouterScroller(router, viewportScroller, config) {
-    if (config.scrollOffset) {
-        viewportScroller.setOffset(config.scrollOffset);
-    }
-    return new RouterScroller(router, viewportScroller, config);
+function provideRouterScroller() {
+    return {
+        provide: ROUTER_SCROLLER,
+        useFactory: () => {
+            const router = inject(Router);
+            const viewportScroller = inject(ViewportScroller);
+            const config = inject(ROUTER_CONFIGURATION);
+            if (config.scrollOffset) {
+                viewportScroller.setOffset(config.scrollOffset);
+            }
+            return new RouterScroller(router, viewportScroller, config);
+        },
+    };
+}
+function provideHashLocationStrategy() {
+    return { provide: LocationStrategy, useClass: HashLocationStrategy };
 }
-function provideLocationStrategy(platformLocationStrategy, baseHref, options = {}) {
-    return options.useHash ? new HashLocationStrategy(platformLocationStrategy, baseHref) :
-        new PathLocationStrategy(platformLocationStrategy, baseHref);
+function providePathLocationStrategy() {
+    return { provide: LocationStrategy, useClass: PathLocationStrategy };
 }
 function provideForRootGuard(router) {
-    if ((typeof ngDevMode === 'undefined' || ngDevMode) && router) {
+    if (NG_DEV_MODE && router) {
         throw new Error(`RouterModule.forRoot() called twice. Lazy loaded modules should use RouterModule.forChild() instead.`);
     }
     return 'guarded';
@@ -6402,17 +6449,6 @@ function setupRouter(urlSerializer, contexts, location, injector, compiler, conf
     }
     router.titleStrategy = titleStrategy !== null && titleStrategy !== void 0 ? titleStrategy : defaultTitleStrategy;
     assignExtraOptionsToRouter(opts, router);
-    if ((typeof ngDevMode === 'undefined' || ngDevMode) && opts.enableTracing) {
-        router.events.subscribe((e) => {
-            var _a, _b;
-            // tslint:disable:no-console
-            (_a = console.group) === null || _a === void 0 ? void 0 : _a.call(console, `Router Event: ${e.constructor.name}`);
-            console.log(stringifyEvent(e));
-            console.log(e);
-            (_b = console.groupEnd) === null || _b === void 0 ? void 0 : _b.call(console);
-            // tslint:enable:no-console
-        });
-    }
     return router;
 }
 function assignExtraOptionsToRouter(opts, router) {
@@ -6441,112 +6477,138 @@ function assignExtraOptionsToRouter(opts, router) {
 function rootRoute(router) {
     return router.routerState.root;
 }
-/**
- * Router initialization requires two steps:
- *
- * First, we start the navigation in a `APP_INITIALIZER` to block the bootstrap if
- * a resolver or a guard executes asynchronously.
- *
- * Next, we actually run activation in a `BOOTSTRAP_LISTENER`, using the
- * `afterPreactivation` hook provided by the router.
- * The router navigation starts, reaches the point when preactivation is done, and then
- * pauses. It waits for the hook to be resolved. We then resolve it only in a bootstrap listener.
- */
-class RouterInitializer {
-    constructor(injector) {
-        this.injector = injector;
-        this.initNavigation = false;
-        this.destroyed = false;
-        this.resultOfPreactivationDone = new Subject();
-    }
-    appInitializer() {
-        const p = this.injector.get(LOCATION_INITIALIZED, Promise.resolve(null));
-        return p.then(() => {
-            // If the injector was destroyed, the DI lookups below will fail.
-            if (this.destroyed) {
-                return Promise.resolve(true);
-            }
-            let resolve = null;
-            const res = new Promise(r => resolve = r);
-            const router = this.injector.get(Router);
-            const opts = this.injector.get(ROUTER_CONFIGURATION);
-            if (opts.initialNavigation === 'disabled') {
-                router.setUpLocationChangeListener();
-                resolve(true);
-            }
-            else if (opts.initialNavigation === 'enabledBlocking') {
-                router.hooks.afterPreactivation = () => {
-                    // only the initial navigation should be delayed
-                    if (!this.initNavigation) {
-                        this.initNavigation = true;
-                        resolve(true);
-                        return this.resultOfPreactivationDone;
-                        // subsequent navigations should not be delayed
-                    }
-                    else {
-                        return of(null);
-                    }
-                };
-                router.initialNavigation();
-            }
-            else {
-                resolve(true);
-            }
-            return res;
-        });
-    }
-    bootstrapListener(bootstrappedComponentRef) {
-        const opts = this.injector.get(ROUTER_CONFIGURATION);
-        const preloader = this.injector.get(RouterPreloader);
-        const routerScroller = this.injector.get(RouterScroller);
-        const router = this.injector.get(Router);
-        const ref = this.injector.get(ApplicationRef);
+function getBootstrapListener() {
+    const injector = inject(Injector);
+    return (bootstrappedComponentRef) => {
+        var _a, _b;
+        const ref = injector.get(ApplicationRef);
         if (bootstrappedComponentRef !== ref.components[0]) {
             return;
         }
+        const router = injector.get(Router);
+        const bootstrapDone = injector.get(BOOTSTRAP_DONE);
         // Default case
-        if (opts.initialNavigation === 'enabledNonBlocking' || opts.initialNavigation === undefined) {
+        if (injector.get(INITIAL_NAVIGATION, null, InjectFlags.Optional) === null) {
             router.initialNavigation();
         }
-        preloader.setUpPreloading();
-        routerScroller.init();
+        (_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]);
-        this.resultOfPreactivationDone.next(null);
-        this.resultOfPreactivationDone.complete();
-    }
-    ngOnDestroy() {
-        this.destroyed = true;
-    }
-}
-RouterInitializer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterInitializer, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-RouterInitializer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterInitializer });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterInitializer, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
-function getAppInitializer(r) {
-    return r.appInitializer.bind(r);
-}
-function getBootstrapListener(r) {
-    return r.bootstrapListener.bind(r);
+        bootstrapDone.next();
+        bootstrapDone.complete();
+    };
 }
+// TODO(atscott): This should not be in the public API
 /**
  * A [DI token](guide/glossary/#di-token) for the router initializer that
  * is called after the app is bootstrapped.
  *
  * @publicApi
  */
-const ROUTER_INITIALIZER = new InjectionToken('Router Initializer');
+const ROUTER_INITIALIZER = new InjectionToken(NG_DEV_MODE ? 'Router Initializer' : '');
+function provideInitialNavigation(config) {
+    return [
+        config.initialNavigation === 'disabled' ? provideDisabledInitialNavigation() : [],
+        config.initialNavigation === 'enabledBlocking' ? provideEnabledBlockingInitialNavigation() : [],
+    ];
+}
 function provideRouterInitializer() {
     return [
-        RouterInitializer,
+        // ROUTER_INITIALIZER token should be removed. It's public API but shouldn't be. We can just
+        // have `getBootstrapListener` directly attached to APP_BOOTSTRAP_LISTENER.
+        { provide: ROUTER_INITIALIZER, useFactory: getBootstrapListener },
+        { provide: APP_BOOTSTRAP_LISTENER, multi: true, useExisting: ROUTER_INITIALIZER },
+    ];
+}
+/**
+ * A subject used to indicate that the bootstrapping phase is done. When initial navigation is
+ * `enabledBlocking`, the first navigation waits until bootstrapping is finished before continuing
+ * to the activation phase.
+ */
+const BOOTSTRAP_DONE = new InjectionToken(NG_DEV_MODE ? 'bootstrap done indicator' : '', {
+    factory: () => {
+        return new Subject();
+    }
+});
+function provideEnabledBlockingInitialNavigation() {
+    return [
+        { provide: INITIAL_NAVIGATION, useValue: 'enabledBlocking' },
         {
             provide: APP_INITIALIZER,
             multi: true,
-            useFactory: getAppInitializer,
-            deps: [RouterInitializer]
+            deps: [Injector],
+            useFactory: (injector) => {
+                const locationInitialized = injector.get(LOCATION_INITIALIZED, Promise.resolve(null));
+                let initNavigation = false;
+                return () => {
+                    return locationInitialized.then(() => {
+                        return new Promise(resolve => {
+                            const router = injector.get(Router);
+                            const bootstrapDone = injector.get(BOOTSTRAP_DONE);
+                            router.afterPreactivation = () => {
+                                // only the initial navigation should be delayed
+                                if (!initNavigation) {
+                                    initNavigation = true;
+                                    resolve(true);
+                                    return bootstrapDone;
+                                    // subsequent navigations should not be delayed
+                                }
+                                else {
+                                    return of(void 0);
+                                }
+                            };
+                            router.initialNavigation();
+                        });
+                    });
+                };
+            }
         },
-        { provide: ROUTER_INITIALIZER, useFactory: getBootstrapListener, deps: [RouterInitializer] },
-        { provide: APP_BOOTSTRAP_LISTENER, multi: true, useExisting: ROUTER_INITIALIZER },
+    ];
+}
+const INITIAL_NAVIGATION = new InjectionToken(NG_DEV_MODE ? 'initial navigation' : '');
+function provideDisabledInitialNavigation() {
+    return [
+        {
+            provide: APP_INITIALIZER,
+            multi: true,
+            useFactory: () => {
+                const router = inject(Router);
+                return () => {
+                    router.setUpLocationChangeListener();
+                };
+            }
+        },
+        { provide: INITIAL_NAVIGATION, useValue: 'disabled' }
+    ];
+}
+function provideTracing() {
+    if (NG_DEV_MODE) {
+        return [{
+                provide: ENVIRONMENT_INITIALIZER,
+                multi: true,
+                useFactory: () => {
+                    const router = inject(Router);
+                    return () => router.events.subscribe((e) => {
+                        var _a, _b;
+                        // tslint:disable:no-console
+                        (_a = console.group) === null || _a === void 0 ? void 0 : _a.call(console, `Router Event: ${e.constructor.name}`);
+                        console.log(stringifyEvent(e));
+                        console.log(e);
+                        (_b = console.groupEnd) === null || _b === void 0 ? void 0 : _b.call(console);
+                        // tslint:enable:no-console
+                    });
+                }
+            }];
+    }
+    else {
+        return [];
+    }
+}
+function providePreloading(preloadingStrategy) {
+    return [
+        RouterPreloader,
+        { provide: ROUTER_PRELOADER, useExisting: RouterPreloader },
+        { provide: PreloadingStrategy, useExisting: preloadingStrategy },
     ];
 }
 
@@ -6560,7 +6622,7 @@ function provideRouterInitializer() {
 /**
  * @publicApi
  */
-const VERSION = new Version('14.1.0-next.0');
+const VERSION = new Version('14.1.0-next.3');
 
 /**
  * @license
@@ -6599,5 +6661,5 @@ const VERSION = new Version('14.1.0-next.0');
  * Generated bundle index. Do not edit.
  */
 
-export { ActivatedRoute, ActivatedRouteSnapshot, ActivationEnd, ActivationStart, BaseRouteReuseStrategy, ChildActivationEnd, ChildActivationStart, ChildrenOutletContexts, DefaultTitleStrategy, DefaultUrlSerializer, GuardsCheckEnd, GuardsCheckStart, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, NoPreloading, OutletContext, PRIMARY_OUTLET, PreloadAllModules, PreloadingStrategy, ROUTER_CONFIGURATION, ROUTER_INITIALIZER, ROUTES, ResolveEnd, ResolveStart, RouteConfigLoadEnd, RouteConfigLoadStart, RouteReuseStrategy, Router, RouterEvent, RouterLink, RouterLinkActive, RouterLinkWithHref, RouterModule, RouterOutlet, RouterPreloader, RouterState, RouterStateSnapshot, RoutesRecognized, Scroll, TitleStrategy, UrlHandlingStrategy, UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree, VERSION, convertToParamMap, createUrlTreeFromSnapshot, provideRoutes, ɵEmptyOutletComponent, ROUTER_PROVIDERS as ɵROUTER_PROVIDERS, assignExtraOptionsToRouter as ɵassignExtraOptionsToRouter, flatten as ɵflatten };
+export { ActivatedRoute, ActivatedRouteSnapshot, ActivationEnd, ActivationStart, BaseRouteReuseStrategy, ChildActivationEnd, ChildActivationStart, ChildrenOutletContexts, DefaultTitleStrategy, DefaultUrlSerializer, GuardsCheckEnd, GuardsCheckStart, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, NoPreloading, OutletContext, PRIMARY_OUTLET, PreloadAllModules, PreloadingStrategy, ROUTER_CONFIGURATION, ROUTER_INITIALIZER, ROUTES, ResolveEnd, ResolveStart, RouteConfigLoadEnd, RouteConfigLoadStart, RouteReuseStrategy, Router, RouterEvent, RouterLink, RouterLinkActive, RouterLinkWithHref, RouterModule, RouterOutlet, RouterPreloader, RouterState, RouterStateSnapshot, RoutesRecognized, Scroll, TitleStrategy, UrlHandlingStrategy, UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree, VERSION, convertToParamMap, createUrlTreeFromSnapshot, provideRoutes, ɵEmptyOutletComponent, ROUTER_PROVIDERS as ɵROUTER_PROVIDERS, assignExtraOptionsToRouter as ɵassignExtraOptionsToRouter, flatten as ɵflatten, providePreloading as ɵprovidePreloading };
 //# sourceMappingURL=router.mjs.map