@angular/router 13.0.0-next.0 → 13.0.0-next.12

package/fesm2015/{router.js → router.mjs}

@@ -1,13 +1,15 @@
 /**
- * @license Angular v13.0.0-next.0
+ * @license Angular v13.0.0-next.12
  * (c) 2010-2021 Google LLC. https://angular.io/
  * License: MIT
  */
 
-import { Location, LocationStrategy, ViewportScroller, PlatformLocation, APP_BASE_HREF, HashLocationStrategy, PathLocationStrategy, LOCATION_INITIALIZED } from '@angular/common';
-import { ɵisObservable, ɵisPromise, Component, NgModuleRef, InjectionToken, InjectFlags, NgModuleFactory, ɵConsole, NgZone, Injectable, Type, Injector, NgModuleFactoryLoader, Compiler, Directive, Attribute, Renderer2, ElementRef, Input, HostListener, HostBinding, ChangeDetectorRef, Optional, ContentChildren, EventEmitter, ViewContainerRef, ComponentFactoryResolver, Output, SystemJsNgModuleLoader, NgProbeToken, ANALYZE_FOR_ENTRY_COMPONENTS, SkipSelf, Inject, APP_INITIALIZER, APP_BOOTSTRAP_LISTENER, NgModule, ApplicationRef, Version } from '@angular/core';
+import * as i0 from '@angular/core';
+import { ɵisObservable, ɵisPromise, EventEmitter, Directive, Attribute, Output, Component, NgModuleRef, InjectionToken, InjectFlags, NgModuleFactory, ɵConsole, NgZone, Injectable, 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, Observable, EmptyError, concat, defer, EMPTY, ConnectableObservable, Subject } from 'rxjs';
 import { map, switchMap, take, startWith, scan, filter, catchError, concatMap, last as last$1, first, mergeMap, tap, takeLast, refCount, finalize, 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';
 
 /**
  * @license
@@ -992,7 +994,7 @@ function matchQueryParams(str) {
     const match = str.match(QUERY_PARAM_RE);
     return match ? match[0] : '';
 }
-const QUERY_PARAM_VALUE_RE = /^[^?&#]+/;
+const QUERY_PARAM_VALUE_RE = /^[^&#]+/;
 // Return the value of the query param at the start of the string or an empty string
 function matchUrlQueryParamValue(str) {
     const match = str.match(QUERY_PARAM_VALUE_RE);
@@ -2280,6 +2282,295 @@ function prioritizedGuardValue() {
     });
 }
 
+/**
+ * @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
+ */
+/**
+ * Store contextual information about a `RouterOutlet`
+ *
+ * @publicApi
+ */
+class OutletContext {
+    constructor() {
+        this.outlet = null;
+        this.route = null;
+        this.resolver = null;
+        this.children = new ChildrenOutletContexts();
+        this.attachRef = null;
+    }
+}
+/**
+ * Store contextual information about the children (= nested) `RouterOutlet`
+ *
+ * @publicApi
+ */
+class ChildrenOutletContexts {
+    constructor() {
+        // contexts for child outlets, by name.
+        this.contexts = new Map();
+    }
+    /** Called when a `RouterOutlet` directive is instantiated */
+    onChildOutletCreated(childName, outlet) {
+        const context = this.getOrCreateContext(childName);
+        context.outlet = outlet;
+        this.contexts.set(childName, context);
+    }
+    /**
+     * Called when a `RouterOutlet` directive is destroyed.
+     * We need to keep the context as the outlet could be destroyed inside a NgIf and might be
+     * re-created later.
+     */
+    onChildOutletDestroyed(childName) {
+        const context = this.getContext(childName);
+        if (context) {
+            context.outlet = null;
+            context.attachRef = null;
+        }
+    }
+    /**
+     * Called when the corresponding route is deactivated during navigation.
+     * Because the component get destroyed, all children outlet are destroyed.
+     */
+    onOutletDeactivated() {
+        const contexts = this.contexts;
+        this.contexts = new Map();
+        return contexts;
+    }
+    onOutletReAttached(contexts) {
+        this.contexts = contexts;
+    }
+    getOrCreateContext(childName) {
+        let context = this.getContext(childName);
+        if (!context) {
+            context = new OutletContext();
+            this.contexts.set(childName, context);
+        }
+        return context;
+    }
+    getContext(childName) {
+        return this.contexts.get(childName) || null;
+    }
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @description
+ *
+ * Acts as a placeholder that Angular dynamically fills based on the current router state.
+ *
+ * Each outlet can have a unique name, determined by the optional `name` attribute.
+ * The name cannot be set or changed dynamically. If not set, default value is "primary".
+ *
+ * ```
+ * <router-outlet></router-outlet>
+ * <router-outlet name='left'></router-outlet>
+ * <router-outlet name='right'></router-outlet>
+ * ```
+ *
+ * Named outlets can be the targets of secondary routes.
+ * The `Route` object for a secondary route has an `outlet` property to identify the target outlet:
+ *
+ * `{path: <base-path>, component: <component>, outlet: <target_outlet_name>}`
+ *
+ * Using named outlets and secondary routes, you can target multiple outlets in
+ * the same `RouterLink` directive.
+ *
+ * The router keeps track of separate branches in a navigation tree for each named outlet and
+ * generates a representation of that tree in the URL.
+ * The URL for a secondary route uses the following syntax to specify both the primary and secondary
+ * routes at the same time:
+ *
+ * `http://base-path/primary-route-path(outlet-name:route-path)`
+ *
+ * A router outlet emits an activate event when a new component is instantiated,
+ * deactivate event when a component is destroyed.
+ * An attached event emits when the `RouteReuseStrategy` instructs the outlet to reattach the
+ * subtree, and the detached event emits when the `RouteReuseStrategy` instructs the outlet to
+ * detach the subtree.
+ *
+ * ```
+ * <router-outlet
+ *   (activate)='onActivate($event)'
+ *   (deactivate)='onDeactivate($event)'
+ *   (attach)='onAttach($event)'
+ *   (detach)='onDetach($event)'></router-outlet>
+ * ```
+ *
+ * @see [Routing tutorial](guide/router-tutorial-toh#named-outlets "Example of a named
+ * outlet and secondary route configuration").
+ * @see `RouterLink`
+ * @see `Route`
+ * @ngModule RouterModule
+ *
+ * @publicApi
+ */
+class RouterOutlet {
+    constructor(parentContexts, location, resolver, name, changeDetector) {
+        this.parentContexts = parentContexts;
+        this.location = location;
+        this.resolver = resolver;
+        this.changeDetector = changeDetector;
+        this.activated = null;
+        this._activatedRoute = null;
+        this.activateEvents = new EventEmitter();
+        this.deactivateEvents = new EventEmitter();
+        /**
+         * Emits an attached component instance when the `RouteReuseStrategy` instructs to re-attach a
+         * previously detached subtree.
+         **/
+        this.attachEvents = new EventEmitter();
+        /**
+         * Emits a detached component instance when the `RouteReuseStrategy` instructs to detach the
+         * subtree.
+         */
+        this.detachEvents = new EventEmitter();
+        this.name = name || PRIMARY_OUTLET;
+        parentContexts.onChildOutletCreated(this.name, this);
+    }
+    /** @nodoc */
+    ngOnDestroy() {
+        this.parentContexts.onChildOutletDestroyed(this.name);
+    }
+    /** @nodoc */
+    ngOnInit() {
+        if (!this.activated) {
+            // If the outlet was not instantiated at the time the route got activated we need to populate
+            // the outlet when it is initialized (ie inside a NgIf)
+            const context = this.parentContexts.getContext(this.name);
+            if (context && context.route) {
+                if (context.attachRef) {
+                    // `attachRef` is populated when there is an existing component to mount
+                    this.attach(context.attachRef, context.route);
+                }
+                else {
+                    // otherwise the component defined in the configuration is created
+                    this.activateWith(context.route, context.resolver || null);
+                }
+            }
+        }
+    }
+    get isActivated() {
+        return !!this.activated;
+    }
+    /**
+     * @returns The currently activated component instance.
+     * @throws An error if the outlet is not activated.
+     */
+    get component() {
+        if (!this.activated)
+            throw new Error('Outlet is not activated');
+        return this.activated.instance;
+    }
+    get activatedRoute() {
+        if (!this.activated)
+            throw new Error('Outlet is not activated');
+        return this._activatedRoute;
+    }
+    get activatedRouteData() {
+        if (this._activatedRoute) {
+            return this._activatedRoute.snapshot.data;
+        }
+        return {};
+    }
+    /**
+     * Called when the `RouteReuseStrategy` instructs to detach the subtree
+     */
+    detach() {
+        if (!this.activated)
+            throw new Error('Outlet is not activated');
+        this.location.detach();
+        const cmp = this.activated;
+        this.activated = null;
+        this._activatedRoute = null;
+        this.detachEvents.emit(cmp.instance);
+        return cmp;
+    }
+    /**
+     * Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree
+     */
+    attach(ref, activatedRoute) {
+        this.activated = ref;
+        this._activatedRoute = activatedRoute;
+        this.location.insert(ref.hostView);
+        this.attachEvents.emit(ref.instance);
+    }
+    deactivate() {
+        if (this.activated) {
+            const c = this.component;
+            this.activated.destroy();
+            this.activated = null;
+            this._activatedRoute = null;
+            this.deactivateEvents.emit(c);
+        }
+    }
+    activateWith(activatedRoute, resolver) {
+        if (this.isActivated) {
+            throw new Error('Cannot activate an already activated outlet');
+        }
+        this._activatedRoute = activatedRoute;
+        const snapshot = activatedRoute._futureSnapshot;
+        const component = snapshot.routeConfig.component;
+        resolver = resolver || this.resolver;
+        const factory = resolver.resolveComponentFactory(component);
+        const childContexts = this.parentContexts.getOrCreateContext(this.name).children;
+        const injector = new OutletInjector(activatedRoute, childContexts, this.location.injector);
+        this.activated = this.location.createComponent(factory, this.location.length, injector);
+        // Calling `markForCheck` to make sure we will run the change detection when the
+        // `RouterOutlet` is inside a `ChangeDetectionStrategy.OnPush` component.
+        this.changeDetector.markForCheck();
+        this.activateEvents.emit(this.activated.instance);
+    }
+}
+RouterOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterOutlet, deps: [{ token: ChildrenOutletContexts }, { token: i0.ViewContainerRef }, { token: i0.ComponentFactoryResolver }, { token: 'name', attribute: true }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+RouterOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.12", 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: "13.0.0-next.12", ngImport: i0, type: RouterOutlet, decorators: [{
+            type: Directive,
+            args: [{ selector: 'router-outlet', exportAs: 'outlet' }]
+        }], ctorParameters: function () {
+        return [{ type: ChildrenOutletContexts }, { type: i0.ViewContainerRef }, { type: i0.ComponentFactoryResolver }, { type: undefined, decorators: [{
+                        type: Attribute,
+                        args: ['name']
+                    }] }, { type: i0.ChangeDetectorRef }];
+    }, propDecorators: { activateEvents: [{
+                type: Output,
+                args: ['activate']
+            }], deactivateEvents: [{
+                type: Output,
+                args: ['deactivate']
+            }], attachEvents: [{
+                type: Output,
+                args: ['attach']
+            }], detachEvents: [{
+                type: Output,
+                args: ['detach']
+            }] } });
+class OutletInjector {
+    constructor(route, childContexts, parent) {
+        this.route = route;
+        this.childContexts = childContexts;
+        this.parent = parent;
+    }
+    get(token, notFoundValue) {
+        if (token === ActivatedRoute) {
+            return this.route;
+        }
+        if (token === ChildrenOutletContexts) {
+            return this.childContexts;
+        }
+        return this.parent.get(token, notFoundValue);
+    }
+}
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -2298,9 +2589,12 @@ function prioritizedGuardValue() {
  */
 class ɵEmptyOutletComponent {
 }
-ɵEmptyOutletComponent.decorators = [
-    { type: Component, args: [{ template: `<router-outlet></router-outlet>` },] }
-];
+ɵEmptyOutletComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ɵEmptyOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0-next.12", type: ɵEmptyOutletComponent, selector: "ng-component", ngImport: i0, template: `<router-outlet></router-outlet>`, isInline: true, directives: [{ type: RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: ɵEmptyOutletComponent, decorators: [{
+            type: Component,
+            args: [{ template: `<router-outlet></router-outlet>` }]
+        }] });
 
 /**
  * @license
@@ -2428,7 +2722,7 @@ function sortByMatchingOutlets(routes, outletName) {
  * 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 = {
+const noMatch$1 = {
     matched: false,
     consumedSegments: [],
     lastChild: 0,
@@ -2439,7 +2733,7 @@ function match(segmentGroup, route, segments) {
     var _a;
     if (route.path === '') {
         if (route.pathMatch === 'full' && (segmentGroup.hasChildren() || segments.length > 0)) {
-            return Object.assign({}, noMatch);
+            return Object.assign({}, noMatch$1);
         }
         return {
             matched: true,
@@ -2452,7 +2746,7 @@ function match(segmentGroup, route, segments) {
     const matcher = route.matcher || defaultUrlMatcher;
     const res = matcher(segments, segmentGroup, route);
     if (!res)
-        return Object.assign({}, noMatch);
+        return Object.assign({}, noMatch$1);
     const posParams = {};
     forEach(res.posParams, (v, k) => {
         posParams[k] = v.path;
@@ -2569,7 +2863,7 @@ function noLeftoversInUrl(segmentGroup, segments, outlet) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-class NoMatch {
+class NoMatch$1 {
     constructor(segmentGroup) {
         this.segmentGroup = segmentGroup || null;
     }
@@ -2579,8 +2873,8 @@ class AbsoluteRedirect {
         this.urlTree = urlTree;
     }
 }
-function noMatch$1(segmentGroup) {
-    return new Observable((obs) => obs.error(new NoMatch(segmentGroup)));
+function noMatch(segmentGroup) {
+    return new Observable((obs) => obs.error(new NoMatch$1(segmentGroup)));
 }
 function absoluteRedirect(newTree) {
     return new Observable((obs) => obs.error(new AbsoluteRedirect(newTree)));
@@ -2596,7 +2890,7 @@ function canLoadFails(route) {
  *
  * Lazy modules are loaded along the way.
  */
-function applyRedirects(moduleInjector, configLoader, urlSerializer, urlTree, config) {
+function applyRedirects$1(moduleInjector, configLoader, urlSerializer, urlTree, config) {
     return new ApplyRedirects(moduleInjector, configLoader, urlSerializer, urlTree, config).apply();
 }
 class ApplyRedirects {
@@ -2629,7 +2923,7 @@ class ApplyRedirects {
                 // we need to run matching, so we can fetch all lazy-loaded modules
                 return this.match(e.urlTree);
             }
-            if (e instanceof NoMatch) {
+            if (e instanceof NoMatch$1) {
                 throw this.noMatchError(e);
             }
             throw e;
@@ -2641,7 +2935,7 @@ class ApplyRedirects {
             return this.createUrlTree(squashSegmentGroup(rootSegmentGroup), tree.queryParams, tree.fragment);
         }));
         return mapped$.pipe(catchError((e) => {
-            if (e instanceof NoMatch) {
+            if (e instanceof NoMatch$1) {
                 throw this.noMatchError(e);
             }
             throw e;
@@ -2694,7 +2988,7 @@ class ApplyRedirects {
         return from(routes).pipe(concatMap((r) => {
             const expanded$ = this.expandSegmentAgainstRoute(ngModule, segmentGroup, routes, r, segments, outlet, allowRedirects);
             return expanded$.pipe(catchError((e) => {
-                if (e instanceof NoMatch) {
+                if (e instanceof NoMatch$1) {
                     return of(null);
                 }
                 throw e;
@@ -2704,14 +2998,14 @@ class ApplyRedirects {
                 if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
                     return of(new UrlSegmentGroup([], {}));
                 }
-                throw new NoMatch(segmentGroup);
+                throw new NoMatch$1(segmentGroup);
             }
             throw e;
         }));
     }
     expandSegmentAgainstRoute(ngModule, segmentGroup, routes, route, paths, outlet, allowRedirects) {
         if (!isImmediateMatch(route, segmentGroup, paths, outlet)) {
-            return noMatch$1(segmentGroup);
+            return noMatch(segmentGroup);
         }
         if (route.redirectTo === undefined) {
             return this.matchSegmentAgainstRoute(ngModule, segmentGroup, route, paths, outlet);
@@ -2719,7 +3013,7 @@ class ApplyRedirects {
         if (allowRedirects && this.allowRedirects) {
             return this.expandSegmentAgainstRouteUsingRedirect(ngModule, segmentGroup, routes, route, paths, outlet);
         }
-        return noMatch$1(segmentGroup);
+        return noMatch(segmentGroup);
     }
     expandSegmentAgainstRouteUsingRedirect(ngModule, segmentGroup, routes, route, segments, outlet) {
         if (route.path === '**') {
@@ -2740,7 +3034,7 @@ class ApplyRedirects {
     expandRegularSegmentAgainstRouteUsingRedirect(ngModule, segmentGroup, routes, route, segments, outlet) {
         const { matched, consumedSegments, lastChild, positionalParamSegments } = match(segmentGroup, route, segments);
         if (!matched)
-            return noMatch$1(segmentGroup);
+            return noMatch(segmentGroup);
         const newTree = this.applyRedirectCommands(consumedSegments, route.redirectTo, positionalParamSegments);
         if (route.redirectTo.startsWith('/')) {
             return absoluteRedirect(newTree);
@@ -2763,7 +3057,7 @@ class ApplyRedirects {
         }
         const { matched, consumedSegments, lastChild } = match(rawSegmentGroup, route, segments);
         if (!matched)
-            return noMatch$1(rawSegmentGroup);
+            return noMatch(rawSegmentGroup);
         const rawSlicedSegments = segments.slice(lastChild);
         const childConfig$ = this.getChildConfig(ngModule, route, segments);
         return childConfig$.pipe(mergeMap((routerConfig) => {
@@ -2941,8 +3235,8 @@ function squashSegmentGroup(segmentGroup) {
  * 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$1(moduleInjector, configLoader, urlSerializer, config) {
-    return switchMap(t => applyRedirects(moduleInjector, configLoader, urlSerializer, t.extractedUrl, config)
+function applyRedirects(moduleInjector, configLoader, urlSerializer, config) {
+    return switchMap(t => applyRedirects$1(moduleInjector, configLoader, urlSerializer, t.extractedUrl, config)
         .pipe(map(urlAfterRedirects => (Object.assign(Object.assign({}, t), { urlAfterRedirects })))));
 }
 
@@ -3234,18 +3528,18 @@ 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
  */
-class NoMatch$1 {
+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(rootComponentType, config, urlTree, url, paramsInheritanceStrategy = 'emptyOnly', relativeLinkResolution = 'legacy') {
+function recognize$1(rootComponentType, config, urlTree, url, paramsInheritanceStrategy = 'emptyOnly', relativeLinkResolution = 'legacy') {
     try {
         const result = new Recognizer(rootComponentType, config, urlTree, url, paramsInheritanceStrategy, relativeLinkResolution)
             .recognize();
         if (result === null) {
-            return newObservableError(new NoMatch$1());
+            return newObservableError(new NoMatch());
         }
         else {
             return of(result);
@@ -3489,8 +3783,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$1(rootComponentType, config, serializer, paramsInheritanceStrategy, relativeLinkResolution) {
-    return mergeMap(t => recognize(rootComponentType, config, t.urlAfterRedirects, serializer(t.urlAfterRedirects), paramsInheritanceStrategy, relativeLinkResolution)
+function recognize(rootComponentType, config, serializer, paramsInheritanceStrategy, relativeLinkResolution) {
+    return mergeMap(t => recognize$1(rootComponentType, config, t.urlAfterRedirects, serializer(t.urlAfterRedirects), paramsInheritanceStrategy, relativeLinkResolution)
         .pipe(map(targetSnapshot => (Object.assign(Object.assign({}, t), { targetSnapshot })))));
 }
 
@@ -3652,8 +3946,8 @@ class DefaultRouteReuseStrategy extends BaseRouteReuseStrategy {
  */
 const ROUTES = new InjectionToken('ROUTES');
 class RouterConfigLoader {
-    constructor(loader, compiler, onLoadStartListener, onLoadEndListener) {
-        this.loader = loader;
+    constructor(injector, compiler, onLoadStartListener, onLoadEndListener) {
+        this.injector = injector;
         this.compiler = compiler;
         this.onLoadStartListener = onLoadStartListener;
         this.onLoadEndListener = onLoadEndListener;
@@ -3687,92 +3981,14 @@ class RouterConfigLoader {
         return route._loader$;
     }
     loadModuleFactory(loadChildren) {
-        if (typeof loadChildren === 'string') {
-            return from(this.loader.load(loadChildren));
-        }
-        else {
-            return wrapIntoObservable(loadChildren()).pipe(mergeMap((t) => {
-                if (t instanceof NgModuleFactory) {
-                    return of(t);
-                }
-                else {
-                    return from(this.compiler.compileModuleAsync(t));
-                }
-            }));
-        }
-    }
-}
-
-/**
- * @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
- */
-/**
- * Store contextual information about a `RouterOutlet`
- *
- * @publicApi
- */
-class OutletContext {
-    constructor() {
-        this.outlet = null;
-        this.route = null;
-        this.resolver = null;
-        this.children = new ChildrenOutletContexts();
-        this.attachRef = null;
-    }
-}
-/**
- * Store contextual information about the children (= nested) `RouterOutlet`
- *
- * @publicApi
- */
-class ChildrenOutletContexts {
-    constructor() {
-        // contexts for child outlets, by name.
-        this.contexts = new Map();
-    }
-    /** Called when a `RouterOutlet` directive is instantiated */
-    onChildOutletCreated(childName, outlet) {
-        const context = this.getOrCreateContext(childName);
-        context.outlet = outlet;
-        this.contexts.set(childName, context);
-    }
-    /**
-     * Called when a `RouterOutlet` directive is destroyed.
-     * We need to keep the context as the outlet could be destroyed inside a NgIf and might be
-     * re-created later.
-     */
-    onChildOutletDestroyed(childName) {
-        const context = this.getContext(childName);
-        if (context) {
-            context.outlet = null;
-        }
-    }
-    /**
-     * Called when the corresponding route is deactivated during navigation.
-     * Because the component get destroyed, all children outlet are destroyed.
-     */
-    onOutletDeactivated() {
-        const contexts = this.contexts;
-        this.contexts = new Map();
-        return contexts;
-    }
-    onOutletReAttached(contexts) {
-        this.contexts = contexts;
-    }
-    getOrCreateContext(childName) {
-        let context = this.getContext(childName);
-        if (!context) {
-            context = new OutletContext();
-            this.contexts.set(childName, context);
-        }
-        return context;
-    }
-    getContext(childName) {
-        return this.contexts.get(childName) || null;
+        return wrapIntoObservable(loadChildren()).pipe(mergeMap((t) => {
+            if (t instanceof NgModuleFactory) {
+                return of(t);
+            }
+            else {
+                return from(this.compiler.compileModuleAsync(t));
+            }
+        }));
     }
 }
 
@@ -3805,15 +4021,8 @@ class DefaultUrlHandlingStrategy {
     merge(newUrlPart, wholeUrl) {
         return newUrlPart;
     }
-}
-
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
+}
+
 function defaultErrorHandler(error) {
     throw error;
 }
@@ -3827,7 +4036,7 @@ function defaultRouterHook(snapshot, runExtras) {
     return of(null);
 }
 /**
- * The equivalent `IsActiveUrlTreeOptions` options for `Router.isActive` is called with `true`
+ * The equivalent `IsActiveMatchOptions` options for `Router.isActive` is called with `true`
  * (exact = true).
  */
 const exactMatchOptions = {
@@ -3837,7 +4046,7 @@ const exactMatchOptions = {
     queryParams: 'exact'
 };
 /**
- * The equivalent `IsActiveUrlTreeOptions` options for `Router.isActive` is called with `false`
+ * The equivalent `IsActiveMatchOptions` options for `Router.isActive` is called with `false`
  * (exact = false).
  */
 const subsetMatchOptions = {
@@ -3863,7 +4072,7 @@ class Router {
      * Creates the router service.
      */
     // TODO: vsavkin make internal after the final is out.
-    constructor(rootComponentType, urlSerializer, rootContexts, location, injector, loader, compiler, config) {
+    constructor(rootComponentType, urlSerializer, rootContexts, location, injector, compiler, config) {
         this.rootComponentType = rootComponentType;
         this.urlSerializer = urlSerializer;
         this.rootContexts = rootContexts;
@@ -3872,11 +4081,6 @@ class Router {
         this.lastSuccessfulNavigation = null;
         this.currentNavigation = null;
         this.disposed = false;
-        /**
-         * Tracks the previously seen location change from the location subscription so we can compare
-         * the two latest to see if they are duplicates. See setUpLocationChangeListener.
-         */
-        this.lastLocationChangeInfo = null;
         this.navigationId = 0;
         /**
          * The id of the currently active page in the router.
@@ -3967,19 +4171,24 @@ class Router {
          * Configures how the Router attempts to restore state when a navigation is cancelled.
          *
          * 'replace' - Always uses `location.replaceState` to set the browser state to the state of the
-         * router before the navigation started.
+         * router before the navigation started. This means that if the URL of the browser is updated
+         * _before_ the navigation is canceled, the Router will simply replace the item in history rather
+         * than trying to restore to the previous location in the session history. This happens most
+         * frequently with `urlUpdateStrategy: 'eager'` and navigations with the browser back/forward
+         * buttons.
          *
-         * 'computed' - Will always return to the same state that corresponds to the actual Angular route
-         * when the navigation gets cancelled right after triggering a `popstate` event.
+         * 'computed' - Will attempt to return to the same index in the session history that corresponds
+         * to the Angular route when the navigation gets cancelled. For example, if the browser back
+         * button is clicked and the navigation is cancelled, the Router will trigger a forward navigation
+         * and vice versa.
          *
-         * The default value is `replace`
+         * Note: the 'computed' option is incompatible with any `UrlHandlingStrategy` which only
+         * handles a portion of the URL because the history restoration navigates to the previous place in
+         * the browser history rather than simply resetting a portion of the URL.
+         *
+         * The default value is `replace`.
          *
-         * @internal
          */
-        // TODO(atscott): Determine how/when/if to make this public API
-        // This shouldn’t be an option at all but may need to be in order to allow migration without a
-        // breaking change. We need to determine if it should be made into public api (or if we forgo
-        // the option and release as a breaking change bug fix in a major version).
         this.canceledNavigationResolution = 'replace';
         const onLoadStart = (r) => this.triggerEvent(new RouteConfigLoadStart(r));
         const onLoadEnd = (r) => this.triggerEvent(new RouteConfigLoadEnd(r));
@@ -3991,7 +4200,7 @@ class Router {
         this.currentUrlTree = createEmptyUrlTree();
         this.rawUrlTree = this.currentUrlTree;
         this.browserUrlTree = this.currentUrlTree;
-        this.configLoader = new RouterConfigLoader(loader, compiler, onLoadStart, onLoadEnd);
+        this.configLoader = new RouterConfigLoader(injector, compiler, onLoadStart, onLoadEnd);
         this.routerState = createEmptyState(this.currentUrlTree, this.rootComponentType);
         this.transitions = new BehaviorSubject({
             id: 0,
@@ -4048,11 +4257,22 @@ class Router {
                         null
                 };
             }), switchMap(t => {
+                const browserUrlTree = this.browserUrlTree.toString();
                 const urlTransition = !this.navigated ||
-                    t.extractedUrl.toString() !== this.browserUrlTree.toString();
+                    t.extractedUrl.toString() !== browserUrlTree ||
+                    // Navigations which succeed or ones which fail and are cleaned up
+                    // correctly should result in `browserUrlTree` and `currentUrlTree`
+                    // matching. If this is not the case, assume something went wrong and try
+                    // processing the URL again.
+                    browserUrlTree !== this.currentUrlTree.toString();
                 const processCurrentUrl = (this.onSameUrlNavigation === 'reload' ? true : urlTransition) &&
                     this.urlHandlingStrategy.shouldProcessUrl(t.rawUrl);
                 if (processCurrentUrl) {
+                    // If the source of the navigation is from a browser event, the URL is
+                    // already updated. We already need to sync the internal state.
+                    if (isBrowserTriggeredNavigation(t.source)) {
+                        this.browserUrlTree = t.extractedUrl;
+                    }
                     return of(t).pipe(
                     // Fire NavigationStart event
                     switchMap(t => {
@@ -4066,18 +4286,20 @@ class Router {
                         return Promise.resolve(t);
                     }), 
                     // ApplyRedirects
-                    applyRedirects$1(this.ngModule.injector, this.configLoader, this.urlSerializer, this.config), 
+                    applyRedirects(this.ngModule.injector, this.configLoader, this.urlSerializer, this.config), 
                     // Update the currentNavigation
+                    // `urlAfterRedirects` is guaranteed to be set after this point
                     tap(t => {
                         this.currentNavigation = Object.assign(Object.assign({}, this.currentNavigation), { finalUrl: t.urlAfterRedirects });
                     }), 
                     // Recognize
-                    recognize$1(this.rootComponentType, this.config, (url) => this.serializeUrl(url), this.paramsInheritanceStrategy, this.relativeLinkResolution), 
+                    recognize(this.rootComponentType, this.config, (url) => this.serializeUrl(url), this.paramsInheritanceStrategy, this.relativeLinkResolution), 
                     // Update URL if in `eager` update mode
                     tap(t => {
                         if (this.urlUpdateStrategy === 'eager') {
                             if (!t.extras.skipLocationChange) {
-                                this.setBrowserUrl(t.urlAfterRedirects, t);
+                                const rawUrl = this.urlHandlingStrategy.merge(t.urlAfterRedirects, t.rawUrl);
+                                this.setBrowserUrl(rawUrl, t);
                             }
                             this.browserUrlTree = t.urlAfterRedirects;
                         }
@@ -4106,7 +4328,6 @@ class Router {
                          * in the browser.
                          */
                         this.rawUrlTree = t.rawUrl;
-                        this.browserUrlTree = t.urlAfterRedirects;
                         t.resolve(null);
                         return EMPTY;
                     }
@@ -4189,7 +4410,7 @@ class Router {
             tap((t) => {
                 this.currentUrlTree = t.urlAfterRedirects;
                 this.rawUrlTree =
-                    this.urlHandlingStrategy.merge(this.currentUrlTree, t.rawUrl);
+                    this.urlHandlingStrategy.merge(t.urlAfterRedirects, t.rawUrl);
                 this.routerState = t.targetRouterState;
                 if (this.urlUpdateStrategy === 'deferred') {
                     if (!t.extras.skipLocationChange) {
@@ -4214,28 +4435,7 @@ class Router {
                  * means. */
                 if (!completed && !errored) {
                     const cancelationReason = `Navigation ID ${t.id} is not equal to the current navigation id ${this.navigationId}`;
-                    if (this.canceledNavigationResolution === 'replace') {
-                        // Must reset to current URL tree here to ensure history.state is set. On
-                        // a fresh page load, if a new navigation comes in before a successful
-                        // navigation completes, there will be nothing in
-                        // history.state.navigationId. This can cause sync problems with
-                        // AngularJS sync code which looks for a value here in order to determine
-                        // whether or not to handle a given popstate event or to leave it to the
-                        // Angular router.
-                        this.restoreHistory(t);
-                        this.cancelNavigationTransition(t, cancelationReason);
-                    }
-                    else {
-                        // We cannot trigger a `location.historyGo` if the
-                        // cancellation was due to a new navigation before the previous could
-                        // complete. This is because `location.historyGo` triggers a `popstate`
-                        // which would also trigger another navigation. Instead, treat this as a
-                        // redirect and do not reset the state.
-                        this.cancelNavigationTransition(t, cancelationReason);
-                        // TODO(atscott): The same problem happens here with a fresh page load
-                        // and a new navigation before that completes where we won't set a page
-                        // id.
-                    }
+                    this.cancelNavigationTransition(t, cancelationReason);
                 }
                 // currentNavigation should always be reset to null here. If navigation was
                 // successful, lastSuccessfulTransition will have already been set. Therefore
@@ -4265,7 +4465,7 @@ class Router {
                         // This is only applicable with initial navigation, so setting
                         // `navigated` only when not redirecting resolves this scenario.
                         this.navigated = true;
-                        this.restoreHistory(t, true);
+                        this.restoreHistory(t);
                     }
                     const navCancel = new NavigationCancel(t.id, this.serializeUrl(t.extractedUrl), e.message);
                     eventsSubject.next(navCancel);
@@ -4283,7 +4483,12 @@ class Router {
                             const mergedTree = this.urlHandlingStrategy.merge(e.url, this.rawUrlTree);
                             const extras = {
                                 skipLocationChange: t.extras.skipLocationChange,
-                                replaceUrl: this.urlUpdateStrategy === 'eager'
+                                // The URL is already updated at this point if we have 'eager' URL
+                                // updates or if the navigation was triggered by the browser (back
+                                // button, URL bar, etc). We want to replace that item in history if
+                                // the navigation is rejected.
+                                replaceUrl: this.urlUpdateStrategy === 'eager' ||
+                                    isBrowserTriggeredNavigation(t.source)
                             };
                             this.scheduleNavigation(mergedTree, 'imperative', null, extras, { resolve: t.resolve, reject: t.reject, promise: t.promise });
                         }, 0);
@@ -4292,7 +4497,7 @@ class Router {
                      * the pre-error state. */
                 }
                 else {
-                    this.restoreHistory(t, true);
+                    this.restoreHistory(t);
                     const navError = new NavigationError(t.id, this.serializeUrl(t.extractedUrl), e);
                     eventsSubject.next(navError);
                     try {
@@ -4317,16 +4522,8 @@ class Router {
         // this will simplify the lifecycle of the router.
         this.routerState.root.component = this.rootComponentType;
     }
-    getTransition() {
-        const transition = this.transitions.value;
-        // This value needs to be set. Other values such as extractedUrl are set on initial navigation
-        // but the urlAfterRedirects may not get set if we aren't processing the new URL *and* not
-        // processing the previous URL.
-        transition.urlAfterRedirects = this.browserUrlTree;
-        return transition;
-    }
     setTransition(t) {
-        this.transitions.next(Object.assign(Object.assign({}, this.getTransition()), t));
+        this.transitions.next(Object.assign(Object.assign({}, this.transitions.value), t));
     }
     /**
      * Sets up the location change listener and performs the initial navigation.
@@ -4348,13 +4545,16 @@ class Router {
         // run into ngZone
         if (!this.locationSubscription) {
             this.locationSubscription = this.location.subscribe(event => {
-                const currentChange = this.extractLocationChangeInfoFromEvent(event);
-                // The `setTimeout` was added in #12160 and is likely to support Angular/AngularJS
-                // hybrid apps.
-                if (this.shouldScheduleNavigation(this.lastLocationChangeInfo, currentChange)) {
+                const source = event['type'] === 'popstate' ? 'popstate' : 'hashchange';
+                if (source === 'popstate') {
+                    // The `setTimeout` was added in #12160 and is likely to support Angular/AngularJS
+                    // hybrid apps.
                     setTimeout(() => {
-                        const { source, state, urlTree } = currentChange;
+                        var _a;
                         const extras = { replaceUrl: true };
+                        // Navigations coming from Angular router have a navigationId state
+                        // property. When this exists, restore the state.
+                        const state = ((_a = event.state) === null || _a === void 0 ? void 0 : _a.navigationId) ? event.state : null;
                         if (state) {
                             const stateCopy = Object.assign({}, state);
                             delete stateCopy.navigationId;
@@ -4363,45 +4563,13 @@ class Router {
                                 extras.state = stateCopy;
                             }
                         }
+                        const urlTree = this.parseUrl(event['url']);
                         this.scheduleNavigation(urlTree, source, state, extras);
                     }, 0);
                 }
-                this.lastLocationChangeInfo = currentChange;
             });
         }
     }
-    /** Extracts router-related information from a `PopStateEvent`. */
-    extractLocationChangeInfoFromEvent(change) {
-        var _a;
-        return {
-            source: change['type'] === 'popstate' ? 'popstate' : 'hashchange',
-            urlTree: this.parseUrl(change['url']),
-            // Navigations coming from Angular router have a navigationId state
-            // property. When this exists, restore the state.
-            state: ((_a = change.state) === null || _a === void 0 ? void 0 : _a.navigationId) ? change.state : null,
-            transitionId: this.getTransition().id
-        };
-    }
-    /**
-     * Determines whether two events triggered by the Location subscription are due to the same
-     * navigation. The location subscription can fire two events (popstate and hashchange) for a
-     * single navigation. The second one should be ignored, that is, we should not schedule another
-     * navigation in the Router.
-     */
-    shouldScheduleNavigation(previous, current) {
-        if (!previous)
-            return true;
-        const sameDestination = current.urlTree.toString() === previous.urlTree.toString();
-        const eventsOccurredAtSameTime = current.transitionId === previous.transitionId;
-        if (!eventsOccurredAtSameTime || !sameDestination) {
-            return true;
-        }
-        if ((current.source === 'hashchange' && previous.source === 'popstate') ||
-            (current.source === 'popstate' && previous.source === 'hashchange')) {
-            return false;
-        }
-        return true;
-    }
     /** The current URL. */
     get url() {
         return this.serializeUrl(this.currentUrlTree);
@@ -4640,33 +4808,32 @@ class Router {
             this.lastSuccessfulNavigation = this.currentNavigation;
             t.resolve(true);
         }, e => {
-            this.console.warn(`Unhandled Navigation Error: `);
+            this.console.warn(`Unhandled Navigation Error: ${e}`);
         });
     }
     scheduleNavigation(rawUrl, source, restoredState, extras, priorPromise) {
-        var _a, _b;
+        var _a, _b, _c;
         if (this.disposed) {
             return Promise.resolve(false);
         }
-        // * Imperative navigations (router.navigate) might trigger additional navigations to the same
-        //   URL via a popstate event and the locationChangeListener. We should skip these duplicate
-        //   navs. Duplicates may also be triggered by attempts to sync AngularJS and Angular router
-        //   states.
+        // * Duplicate navigations may also be triggered by attempts to sync AngularJS and Angular
+        // router states.
         // * Imperative navigations can be cancelled by router guards, meaning the URL won't change. If
         //   the user follows that with a navigation using the back/forward button or manual URL change,
         //   the destination may be the same as the previous imperative attempt. We should not skip
         //   these navigations because it's a separate case from the one above -- it's not a duplicate
         //   navigation.
-        const lastNavigation = this.getTransition();
+        const lastNavigation = this.transitions.value;
         // We don't want to skip duplicate successful navs if they're imperative because
         // onSameUrlNavigation could be 'reload' (so the duplicate is intended).
-        const browserNavPrecededByRouterNav = source !== 'imperative' && (lastNavigation === null || lastNavigation === void 0 ? void 0 : lastNavigation.source) === 'imperative';
+        const browserNavPrecededByRouterNav = isBrowserTriggeredNavigation(source) && lastNavigation &&
+            !isBrowserTriggeredNavigation(lastNavigation.source);
         const lastNavigationSucceeded = this.lastSuccessfulId === lastNavigation.id;
         // If the last navigation succeeded or is in flight, we can use the rawUrl as the comparison.
         // However, if it failed, we should compare to the final result (urlAfterRedirects).
         const lastNavigationUrl = (lastNavigationSucceeded || this.currentNavigation) ?
             lastNavigation.rawUrl :
-            lastNavigation.urlAfterRedirects;
+            ((_a = lastNavigation.urlAfterRedirects) !== null && _a !== void 0 ? _a : this.browserUrlTree);
         const duplicateNav = lastNavigationUrl.toString() === rawUrl.toString();
         if (browserNavPrecededByRouterNav && duplicateNav) {
             return Promise.resolve(true); // return value is not used
@@ -4702,10 +4869,10 @@ class Router {
                 // If we're replacing the URL or doing a silent navigation, we do not want to increment the
                 // page id because we aren't pushing a new entry to history.
                 if (extras.replaceUrl || extras.skipLocationChange) {
-                    targetPageId = (_a = this.browserPageId) !== null && _a !== void 0 ? _a : 0;
+                    targetPageId = (_b = this.browserPageId) !== null && _b !== void 0 ? _b : 0;
                 }
                 else {
-                    targetPageId = ((_b = this.browserPageId) !== null && _b !== void 0 ? _b : 0) + 1;
+                    targetPageId = ((_c = this.browserPageId) !== null && _c !== void 0 ? _c : 0) + 1;
                 }
             }
         }
@@ -4748,7 +4915,7 @@ class Router {
      * Performs the necessary rollback action to restore the browser URL to the
      * state before the transition.
      */
-    restoreHistory(t, restoringFromCaughtError = false) {
+    restoreHistory(t) {
         var _a, _b;
         if (this.canceledNavigationResolution === 'computed') {
             const targetPagePosition = this.currentPageId - t.targetPageId;
@@ -4770,7 +4937,6 @@ class Router {
                 // TODO(atscott): resetting the `browserUrlTree` should really be done in `resetState`.
                 // Investigate if this can be done by running TGP.
                 this.browserUrlTree = t.currentUrlTree;
-                this.resetUrlToCurrentUrlTree();
             }
             else {
                 // The browser URL and router state was not updated before the navigation cancelled so
@@ -4778,20 +4944,19 @@ class Router {
             }
         }
         else if (this.canceledNavigationResolution === 'replace') {
-            // TODO(atscott): It seems like we should _always_ reset the state here. It would be a no-op
-            // for `deferred` navigations that haven't change the internal state yet because guards
-            // reject. For 'eager' navigations, it seems like we also really should reset the state
-            // because the navigation was cancelled. Investigate if this can be done by running TGP.
-            if (restoringFromCaughtError) {
-                this.resetState(t);
-            }
-            this.resetUrlToCurrentUrlTree();
+            this.resetState(t);
         }
     }
     resetState(t) {
         this.routerState = t.currentRouterState;
         this.currentUrlTree = t.currentUrlTree;
+        // Note here that we use the urlHandlingStrategy to get the reset `rawUrlTree` because it may be
+        // configured to handle only part of the navigation URL. This means we would only want to reset
+        // the part of the navigation handled by the Angular router rather than the whole URL. In
+        // addition, the URLHandlingStrategy may be configured to specifically preserve parts of the URL
+        // when merging, such as the query params so they are not lost on a refresh.
         this.rawUrlTree = this.urlHandlingStrategy.merge(this.currentUrlTree, t.rawUrl);
+        this.resetUrlToCurrentUrlTree();
     }
     resetUrlToCurrentUrlTree() {
         this.location.replaceState(this.urlSerializer.serialize(this.rawUrlTree), '', this.generateNgRouterState(this.lastSuccessfulId, this.currentPageId));
@@ -4808,19 +4973,11 @@ class Router {
         return { navigationId };
     }
 }
-Router.decorators = [
-    { type: Injectable }
-];
-Router.ctorParameters = () => [
-    { type: Type },
-    { type: UrlSerializer },
-    { type: ChildrenOutletContexts },
-    { type: Location },
-    { type: Injector },
-    { type: NgModuleFactoryLoader },
-    { type: Compiler },
-    { type: undefined }
-];
+Router.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: Router, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+Router.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: Router });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: Router, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Type }, { type: UrlSerializer }, { type: ChildrenOutletContexts }, { type: i3.Location }, { type: i0.Injector }, { type: i0.Compiler }, { type: undefined }]; } });
 function validateCommands(commands) {
     for (let i = 0; i < commands.length; i++) {
         const cmd = commands[i];
@@ -4829,14 +4986,10 @@ function validateCommands(commands) {
         }
     }
 }
+function isBrowserTriggeredNavigation(source) {
+    return source !== 'imperative';
+}
 
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
 /**
  * @description
  *
@@ -4935,14 +5088,32 @@ function validateCommands(commands) {
  * @publicApi
  */
 class RouterLink {
-    constructor(router, route, tabIndex, renderer, el) {
+    constructor(router, route, tabIndexAttribute, renderer, el) {
         this.router = router;
         this.route = route;
-        this.commands = [];
+        this.tabIndexAttribute = tabIndexAttribute;
+        this.renderer = renderer;
+        this.el = el;
+        this.commands = null;
         /** @internal */
         this.onChanges = new Subject();
-        if (tabIndex == null) {
-            renderer.setAttribute(el.nativeElement, 'tabindex', '0');
+        this.setTabIndexIfNotOnNativeEl('0');
+    }
+    /**
+     * Modifies the tab index if there was not a tabindex attribute on the element during
+     * instantiation.
+     */
+    setTabIndexIfNotOnNativeEl(newTabIndex) {
+        if (this.tabIndexAttribute != null /* both `null` and `undefined` */) {
+            return;
+        }
+        const renderer = this.renderer;
+        const nativeElement = this.el.nativeElement;
+        if (newTabIndex !== null) {
+            renderer.setAttribute(nativeElement, 'tabindex', newTabIndex);
+        }
+        else {
+            renderer.removeAttribute(nativeElement, 'tabindex');
         }
     }
     /** @nodoc */
@@ -4955,19 +5126,24 @@ class RouterLink {
      * Commands to pass to {@link Router#createUrlTree Router#createUrlTree}.
      *   - **array**: commands to pass to {@link Router#createUrlTree Router#createUrlTree}.
      *   - **string**: shorthand for array of commands with just the string, i.e. `['/route']`
-     *   - **null|undefined**: shorthand for an empty array of commands, i.e. `[]`
+     *   - **null|undefined**: effectively disables the `routerLink`
      * @see {@link Router#createUrlTree Router#createUrlTree}
      */
     set routerLink(commands) {
         if (commands != null) {
             this.commands = Array.isArray(commands) ? commands : [commands];
+            this.setTabIndexIfNotOnNativeEl('0');
         }
         else {
-            this.commands = [];
+            this.commands = null;
+            this.setTabIndexIfNotOnNativeEl(null);
         }
     }
     /** @nodoc */
     onClick() {
+        if (this.urlTree === null) {
+            return true;
+        }
         const extras = {
             skipLocationChange: attrBoolValue(this.skipLocationChange),
             replaceUrl: attrBoolValue(this.replaceUrl),
@@ -4977,6 +5153,9 @@ class RouterLink {
         return true;
     }
     get urlTree() {
+        if (this.commands === null) {
+            return null;
+        }
         return this.router.createUrlTree(this.commands, {
             // If the `relativeTo` input is not defined, we want to use `this.route` by default.
             // Otherwise, we should use the value provided by the user in the input.
@@ -4988,28 +5167,38 @@ class RouterLink {
         });
     }
 }
-RouterLink.decorators = [
-    { type: Directive, args: [{ selector: ':not(a):not(area)[routerLink]' },] }
-];
-RouterLink.ctorParameters = () => [
-    { type: Router },
-    { type: ActivatedRoute },
-    { type: String, decorators: [{ type: Attribute, args: ['tabindex',] }] },
-    { type: Renderer2 },
-    { type: ElementRef }
-];
-RouterLink.propDecorators = {
-    queryParams: [{ type: Input }],
-    fragment: [{ type: Input }],
-    queryParamsHandling: [{ type: Input }],
-    preserveFragment: [{ type: Input }],
-    skipLocationChange: [{ type: Input }],
-    replaceUrl: [{ type: Input }],
-    state: [{ type: Input }],
-    relativeTo: [{ type: Input }],
-    routerLink: [{ type: Input }],
-    onClick: [{ type: HostListener, args: ['click',] }]
-};
+RouterLink.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", 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: "12.0.0", version: "13.0.0-next.12", 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: "13.0.0-next.12", ngImport: i0, type: RouterLink, decorators: [{
+            type: Directive,
+            args: [{ selector: ':not(a):not(area)[routerLink]' }]
+        }], ctorParameters: function () {
+        return [{ type: Router }, { type: ActivatedRoute }, { type: undefined, decorators: [{
+                        type: Attribute,
+                        args: ['tabindex']
+                    }] }, { type: i0.Renderer2 }, { type: i0.ElementRef }];
+    }, propDecorators: { queryParams: [{
+                type: Input
+            }], fragment: [{
+                type: Input
+            }], queryParamsHandling: [{
+                type: Input
+            }], preserveFragment: [{
+                type: Input
+            }], skipLocationChange: [{
+                type: Input
+            }], replaceUrl: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], relativeTo: [{
+                type: Input
+            }], routerLink: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
 /**
  * @description
  *
@@ -5026,7 +5215,11 @@ class RouterLinkWithHref {
         this.router = router;
         this.route = route;
         this.locationStrategy = locationStrategy;
-        this.commands = [];
+        this.commands = null;
+        // the url displayed on the anchor element.
+        // @HostBinding('attr.href') is used rather than @HostBinding() because it removes the
+        // href attribute when it becomes `null`.
+        this.href = null;
         /** @internal */
         this.onChanges = new Subject();
         this.subscription = router.events.subscribe((s) => {
@@ -5039,7 +5232,7 @@ class RouterLinkWithHref {
      * Commands to pass to {@link Router#createUrlTree Router#createUrlTree}.
      *   - **array**: commands to pass to {@link Router#createUrlTree Router#createUrlTree}.
      *   - **string**: shorthand for array of commands with just the string, i.e. `['/route']`
-     *   - **null|undefined**: shorthand for an empty array of commands, i.e. `[]`
+     *   - **null|undefined**: Disables the link by removing the `href`
      * @see {@link Router#createUrlTree Router#createUrlTree}
      */
     set routerLink(commands) {
@@ -5047,7 +5240,7 @@ class RouterLinkWithHref {
             this.commands = Array.isArray(commands) ? commands : [commands];
         }
         else {
-            this.commands = [];
+            this.commands = null;
         }
     }
     /** @nodoc */
@@ -5064,7 +5257,7 @@ class RouterLinkWithHref {
         if (button !== 0 || ctrlKey || shiftKey || altKey || metaKey) {
             return true;
         }
-        if (typeof this.target === 'string' && this.target != '_self') {
+        if (typeof this.target === 'string' && this.target != '_self' || this.urlTree === null) {
             return true;
         }
         const extras = {
@@ -5076,9 +5269,14 @@ class RouterLinkWithHref {
         return false;
     }
     updateTargetUrlAndHref() {
-        this.href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.urlTree));
+        this.href = this.urlTree !== null ?
+            this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.urlTree)) :
+            null;
     }
     get urlTree() {
+        if (this.commands === null) {
+            return null;
+        }
         return this.router.createUrlTree(this.commands, {
             // If the `relativeTo` input is not defined, we want to use `this.route` by default.
             // Otherwise, we should use the value provided by the user in the input.
@@ -5090,29 +5288,42 @@ class RouterLinkWithHref {
         });
     }
 }
-RouterLinkWithHref.decorators = [
-    { type: Directive, args: [{ selector: 'a[routerLink],area[routerLink]' },] }
-];
-RouterLinkWithHref.ctorParameters = () => [
-    { type: Router },
-    { type: ActivatedRoute },
-    { type: LocationStrategy }
-];
-RouterLinkWithHref.propDecorators = {
-    target: [{ type: HostBinding, args: ['attr.target',] }, { type: Input }],
-    queryParams: [{ type: Input }],
-    fragment: [{ type: Input }],
-    queryParamsHandling: [{ type: Input }],
-    preserveFragment: [{ type: Input }],
-    skipLocationChange: [{ type: Input }],
-    replaceUrl: [{ type: Input }],
-    state: [{ type: Input }],
-    relativeTo: [{ type: Input }],
-    href: [{ type: HostBinding }],
-    routerLink: [{ type: Input }],
-    onClick: [{ type: HostListener, args: ['click',
-                ['$event.button', '$event.ctrlKey', '$event.shiftKey', '$event.altKey', '$event.metaKey'],] }]
-};
+RouterLinkWithHref.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterLinkWithHref, deps: [{ token: Router }, { token: ActivatedRoute }, { token: i3.LocationStrategy }], target: i0.ɵɵFactoryTarget.Directive });
+RouterLinkWithHref.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.12", 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: "13.0.0-next.12", 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: [{
+                type: HostBinding,
+                args: ['attr.target']
+            }, {
+                type: Input
+            }], queryParams: [{
+                type: Input
+            }], fragment: [{
+                type: Input
+            }], queryParamsHandling: [{
+                type: Input
+            }], preserveFragment: [{
+                type: Input
+            }], skipLocationChange: [{
+                type: Input
+            }], replaceUrl: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], relativeTo: [{
+                type: Input
+            }], href: [{
+                type: HostBinding,
+                args: ['attr.href']
+            }], routerLink: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click',
+                    ['$event.button', '$event.ctrlKey', '$event.shiftKey', '$event.altKey', '$event.metaKey']]
+            }] } });
 function attrBoolValue(s) {
     return s === '' || !!s;
 }
@@ -5201,6 +5412,23 @@ class RouterLinkActive {
          * @see Router.isActive
          */
         this.routerLinkActiveOptions = { exact: false };
+        /**
+         *
+         * You can use the output `isActiveChange` to get notified each time the link becomes
+         * active or inactive.
+         *
+         * Emits:
+         * true  -> Route is active
+         * false -> Route is inactive
+         *
+         * ```
+         * <a
+         *  routerLink="/user/bob"
+         *  routerLinkActive="active-link"
+         *  (isActiveChange)="this.onRouterLinkActive($event)">Bob</a>
+         * ```
+         */
+        this.isActiveChange = new EventEmitter();
         this.routerEventsSubscription = router.events.subscribe((s) => {
             if (s instanceof NavigationEnd) {
                 this.update();
@@ -5257,15 +5485,17 @@ class RouterLinkActive {
                         this.renderer.removeClass(this.element.nativeElement, c);
                     }
                 });
+                // Emit on isActiveChange after classes are updated
+                this.isActiveChange.emit(hasActiveLinks);
             }
         });
     }
     isLinkActive(router) {
-        const options = 'paths' in this.routerLinkActiveOptions ?
+        const options = isActiveMatchOptions(this.routerLinkActiveOptions) ?
             this.routerLinkActiveOptions :
             // While the types should disallow `undefined` here, it's possible without strict inputs
             (this.routerLinkActiveOptions.exact || false);
-        return (link) => router.isActive(link.urlTree, options);
+        return (link) => link.urlTree ? router.isActive(link.urlTree, options) : false;
     }
     hasActiveLinks() {
         const isActiveCheckFn = this.isLinkActive(this.router);
@@ -5274,214 +5504,38 @@ class RouterLinkActive {
             this.links.some(isActiveCheckFn) || this.linksWithHrefs.some(isActiveCheckFn);
     }
 }
-RouterLinkActive.decorators = [
-    { type: Directive, args: [{
-                selector: '[routerLinkActive]',
-                exportAs: 'routerLinkActive',
-            },] }
-];
-RouterLinkActive.ctorParameters = () => [
-    { type: Router },
-    { type: ElementRef },
-    { type: Renderer2 },
-    { type: ChangeDetectorRef },
-    { type: RouterLink, decorators: [{ type: Optional }] },
-    { type: RouterLinkWithHref, decorators: [{ type: Optional }] }
-];
-RouterLinkActive.propDecorators = {
-    links: [{ type: ContentChildren, args: [RouterLink, { descendants: true },] }],
-    linksWithHrefs: [{ type: ContentChildren, args: [RouterLinkWithHref, { descendants: true },] }],
-    routerLinkActiveOptions: [{ type: Input }],
-    routerLinkActive: [{ type: Input }]
-};
-
-/**
- * @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
- */
+RouterLinkActive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", 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: "12.0.0", version: "13.0.0-next.12", type: RouterLinkActive, selector: "[routerLinkActive]", inputs: { routerLinkActiveOptions: "routerLinkActiveOptions", 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: "13.0.0-next.12", ngImport: i0, type: RouterLinkActive, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[routerLinkActive]',
+                    exportAs: 'routerLinkActive',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: Router }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }, { type: RouterLink, decorators: [{
+                        type: Optional
+                    }] }, { type: RouterLinkWithHref, decorators: [{
+                        type: Optional
+                    }] }];
+    }, propDecorators: { links: [{
+                type: ContentChildren,
+                args: [RouterLink, { descendants: true }]
+            }], linksWithHrefs: [{
+                type: ContentChildren,
+                args: [RouterLinkWithHref, { descendants: true }]
+            }], routerLinkActiveOptions: [{
+                type: Input
+            }], isActiveChange: [{
+                type: Output
+            }], routerLinkActive: [{
+                type: Input
+            }] } });
 /**
- * @description
- *
- * Acts as a placeholder that Angular dynamically fills based on the current router state.
- *
- * Each outlet can have a unique name, determined by the optional `name` attribute.
- * The name cannot be set or changed dynamically. If not set, default value is "primary".
- *
- * ```
- * <router-outlet></router-outlet>
- * <router-outlet name='left'></router-outlet>
- * <router-outlet name='right'></router-outlet>
- * ```
- *
- * Named outlets can be the targets of secondary routes.
- * The `Route` object for a secondary route has an `outlet` property to identify the target outlet:
- *
- * `{path: <base-path>, component: <component>, outlet: <target_outlet_name>}`
- *
- * Using named outlets and secondary routes, you can target multiple outlets in
- * the same `RouterLink` directive.
- *
- * The router keeps track of separate branches in a navigation tree for each named outlet and
- * generates a representation of that tree in the URL.
- * The URL for a secondary route uses the following syntax to specify both the primary and secondary
- * routes at the same time:
- *
- * `http://base-path/primary-route-path(outlet-name:route-path)`
- *
- * A router outlet emits an activate event when a new component is instantiated,
- * and a deactivate event when a component is destroyed.
- *
- * ```
- * <router-outlet
- *   (activate)='onActivate($event)'
- *   (deactivate)='onDeactivate($event)'></router-outlet>
- * ```
- *
- * @see [Routing tutorial](guide/router-tutorial-toh#named-outlets "Example of a named
- * outlet and secondary route configuration").
- * @see `RouterLink`
- * @see `Route`
- * @ngModule RouterModule
- *
- * @publicApi
+ * Use instead of `'paths' in options` to be compatible with property renaming
  */
-class RouterOutlet {
-    constructor(parentContexts, location, resolver, name, changeDetector) {
-        this.parentContexts = parentContexts;
-        this.location = location;
-        this.resolver = resolver;
-        this.changeDetector = changeDetector;
-        this.activated = null;
-        this._activatedRoute = null;
-        this.activateEvents = new EventEmitter();
-        this.deactivateEvents = new EventEmitter();
-        this.name = name || PRIMARY_OUTLET;
-        parentContexts.onChildOutletCreated(this.name, this);
-    }
-    /** @nodoc */
-    ngOnDestroy() {
-        this.parentContexts.onChildOutletDestroyed(this.name);
-    }
-    /** @nodoc */
-    ngOnInit() {
-        if (!this.activated) {
-            // If the outlet was not instantiated at the time the route got activated we need to populate
-            // the outlet when it is initialized (ie inside a NgIf)
-            const context = this.parentContexts.getContext(this.name);
-            if (context && context.route) {
-                if (context.attachRef) {
-                    // `attachRef` is populated when there is an existing component to mount
-                    this.attach(context.attachRef, context.route);
-                }
-                else {
-                    // otherwise the component defined in the configuration is created
-                    this.activateWith(context.route, context.resolver || null);
-                }
-            }
-        }
-    }
-    get isActivated() {
-        return !!this.activated;
-    }
-    /**
-     * @returns The currently activated component instance.
-     * @throws An error if the outlet is not activated.
-     */
-    get component() {
-        if (!this.activated)
-            throw new Error('Outlet is not activated');
-        return this.activated.instance;
-    }
-    get activatedRoute() {
-        if (!this.activated)
-            throw new Error('Outlet is not activated');
-        return this._activatedRoute;
-    }
-    get activatedRouteData() {
-        if (this._activatedRoute) {
-            return this._activatedRoute.snapshot.data;
-        }
-        return {};
-    }
-    /**
-     * Called when the `RouteReuseStrategy` instructs to detach the subtree
-     */
-    detach() {
-        if (!this.activated)
-            throw new Error('Outlet is not activated');
-        this.location.detach();
-        const cmp = this.activated;
-        this.activated = null;
-        this._activatedRoute = null;
-        return cmp;
-    }
-    /**
-     * Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree
-     */
-    attach(ref, activatedRoute) {
-        this.activated = ref;
-        this._activatedRoute = activatedRoute;
-        this.location.insert(ref.hostView);
-    }
-    deactivate() {
-        if (this.activated) {
-            const c = this.component;
-            this.activated.destroy();
-            this.activated = null;
-            this._activatedRoute = null;
-            this.deactivateEvents.emit(c);
-        }
-    }
-    activateWith(activatedRoute, resolver) {
-        if (this.isActivated) {
-            throw new Error('Cannot activate an already activated outlet');
-        }
-        this._activatedRoute = activatedRoute;
-        const snapshot = activatedRoute._futureSnapshot;
-        const component = snapshot.routeConfig.component;
-        resolver = resolver || this.resolver;
-        const factory = resolver.resolveComponentFactory(component);
-        const childContexts = this.parentContexts.getOrCreateContext(this.name).children;
-        const injector = new OutletInjector(activatedRoute, childContexts, this.location.injector);
-        this.activated = this.location.createComponent(factory, this.location.length, injector);
-        // Calling `markForCheck` to make sure we will run the change detection when the
-        // `RouterOutlet` is inside a `ChangeDetectionStrategy.OnPush` component.
-        this.changeDetector.markForCheck();
-        this.activateEvents.emit(this.activated.instance);
-    }
-}
-RouterOutlet.decorators = [
-    { type: Directive, args: [{ selector: 'router-outlet', exportAs: 'outlet' },] }
-];
-RouterOutlet.ctorParameters = () => [
-    { type: ChildrenOutletContexts },
-    { type: ViewContainerRef },
-    { type: ComponentFactoryResolver },
-    { type: String, decorators: [{ type: Attribute, args: ['name',] }] },
-    { type: ChangeDetectorRef }
-];
-RouterOutlet.propDecorators = {
-    activateEvents: [{ type: Output, args: ['activate',] }],
-    deactivateEvents: [{ type: Output, args: ['deactivate',] }]
-};
-class OutletInjector {
-    constructor(route, childContexts, parent) {
-        this.route = route;
-        this.childContexts = childContexts;
-        this.parent = parent;
-    }
-    get(token, notFoundValue) {
-        if (token === ActivatedRoute) {
-            return this.route;
-        }
-        if (token === ChildrenOutletContexts) {
-            return this.childContexts;
-        }
-        return this.parent.get(token, notFoundValue);
-    }
+function isActiveMatchOptions(options) {
+    return !!options.paths;
 }
 
 /**
@@ -5543,13 +5597,13 @@ class NoPreloading {
  * @publicApi
  */
 class RouterPreloader {
-    constructor(router, moduleLoader, compiler, injector, preloadingStrategy) {
+    constructor(router, compiler, injector, preloadingStrategy) {
         this.router = router;
         this.injector = injector;
         this.preloadingStrategy = preloadingStrategy;
         const onStartLoad = (r) => router.triggerEvent(new RouteConfigLoadStart(r));
         const onEndLoad = (r) => router.triggerEvent(new RouteConfigLoadEnd(r));
-        this.loader = new RouterConfigLoader(moduleLoader, compiler, onStartLoad, onEndLoad);
+        this.loader = new RouterConfigLoader(injector, compiler, onStartLoad, onEndLoad);
     }
     setUpPreloading() {
         this.subscription =
@@ -5597,24 +5651,12 @@ class RouterPreloader {
         });
     }
 }
-RouterPreloader.decorators = [
-    { type: Injectable }
-];
-RouterPreloader.ctorParameters = () => [
-    { type: Router },
-    { type: NgModuleFactoryLoader },
-    { type: Compiler },
-    { type: Injector },
-    { type: PreloadingStrategy }
-];
+RouterPreloader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterPreloader, deps: [{ token: Router }, { token: i0.Compiler }, { token: i0.Injector }, { token: PreloadingStrategy }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterPreloader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterPreloader });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterPreloader, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: Router }, { type: i0.Compiler }, { type: i0.Injector }, { type: PreloadingStrategy }]; } });
 
-/**
- * @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 RouterScroller {
     constructor(router, 
     /** @docsNotRequired */ viewportScroller, options = {}) {
@@ -5690,14 +5732,11 @@ class RouterScroller {
         }
     }
 }
-RouterScroller.decorators = [
-    { type: Injectable }
-];
-RouterScroller.ctorParameters = () => [
-    { type: Router },
-    { type: ViewportScroller },
-    { type: undefined }
-];
+RouterScroller.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+RouterScroller.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterScroller });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterScroller, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: Router }, { type: i3.ViewportScroller }, { type: undefined }]; } });
 
 /**
  * @license
@@ -5720,7 +5759,6 @@ const ROUTER_CONFIGURATION = new InjectionToken('ROUTER_CONFIGURATION');
  * @docsNotRequired
  */
 const ROUTER_FORROOT_GUARD = new InjectionToken('ROUTER_FORROOT_GUARD');
-const ɵ0 = { enableTracing: false };
 const ROUTER_PROVIDERS = [
     Location,
     { provide: UrlSerializer, useClass: DefaultUrlSerializer },
@@ -5728,18 +5766,17 @@ const ROUTER_PROVIDERS = [
         provide: Router,
         useFactory: setupRouter,
         deps: [
-            UrlSerializer, ChildrenOutletContexts, Location, Injector, NgModuleFactoryLoader, Compiler,
-            ROUTES, ROUTER_CONFIGURATION, [UrlHandlingStrategy, new Optional()],
+            UrlSerializer, ChildrenOutletContexts, Location, Injector, Compiler, ROUTES,
+            ROUTER_CONFIGURATION, [UrlHandlingStrategy, new Optional()],
             [RouteReuseStrategy, new Optional()]
         ]
     },
     ChildrenOutletContexts,
     { provide: ActivatedRoute, useFactory: rootRoute, deps: [Router] },
-    { provide: NgModuleFactoryLoader, useClass: SystemJsNgModuleLoader },
     RouterPreloader,
     NoPreloading,
     PreloadAllModules,
-    { provide: ROUTER_CONFIGURATION, useValue: ɵ0 },
+    { provide: ROUTER_CONFIGURATION, useValue: { enableTracing: false } },
 ];
 function routerNgProbeToken() {
     return new NgProbeToken('Router', Router);
@@ -5838,17 +5875,26 @@ class RouterModule {
         return { ngModule: RouterModule, providers: [provideRoutes(routes)] };
     }
 }
-RouterModule.decorators = [
-    { type: NgModule, args: [{
-                declarations: ROUTER_DIRECTIVES,
-                exports: ROUTER_DIRECTIVES,
-                entryComponents: [ɵEmptyOutletComponent]
-            },] }
-];
-RouterModule.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [ROUTER_FORROOT_GUARD,] }] },
-    { type: Router, decorators: [{ type: Optional }] }
-];
+RouterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterModule, deps: [{ token: ROUTER_FORROOT_GUARD, optional: true }, { token: Router, optional: true }], target: i0.ɵɵFactoryTarget.NgModule });
+RouterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.12", 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: "13.0.0-next.12", ngImport: i0, type: RouterModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: ROUTER_DIRECTIVES,
+                    exports: ROUTER_DIRECTIVES,
+                    entryComponents: [ɵEmptyOutletComponent]
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [ROUTER_FORROOT_GUARD]
+                    }] }, { type: Router, decorators: [{
+                        type: Optional
+                    }] }];
+    } });
 function createRouterScroller(router, viewportScroller, config) {
     if (config.scrollOffset) {
         viewportScroller.setOffset(config.scrollOffset);
@@ -5887,8 +5933,8 @@ function provideRoutes(routes) {
         { provide: ROUTES, multi: true, useValue: routes },
     ];
 }
-function setupRouter(urlSerializer, contexts, location, injector, loader, compiler, config, opts = {}, urlHandlingStrategy, routeReuseStrategy) {
-    const router = new Router(null, urlSerializer, contexts, location, injector, loader, compiler, flatten(config));
+function setupRouter(urlSerializer, contexts, location, injector, compiler, config, opts = {}, urlHandlingStrategy, routeReuseStrategy) {
+    const router = new Router(null, urlSerializer, contexts, location, injector, compiler, flatten(config));
     if (urlHandlingStrategy) {
         router.urlHandlingStrategy = urlHandlingStrategy;
     }
@@ -6011,12 +6057,11 @@ class RouterInitializer {
         this.destroyed = true;
     }
 }
-RouterInitializer.decorators = [
-    { type: Injectable }
-];
-RouterInitializer.ctorParameters = () => [
-    { type: Injector }
-];
+RouterInitializer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterInitializer, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterInitializer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterInitializer });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: RouterInitializer, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 function getAppInitializer(r) {
     return r.appInitializer.bind(r);
 }
@@ -6054,7 +6099,7 @@ function provideRouterInitializer() {
 /**
  * @publicApi
  */
-const VERSION = new Version('13.0.0-next.0');
+const VERSION = new Version('13.0.0-next.12');
 
 /**
  * @license
@@ -6093,5 +6138,5 @@ const VERSION = new Version('13.0.0-next.0');
  * Generated bundle index. Do not edit.
  */
 
-export { ActivatedRoute, ActivatedRouteSnapshot, ActivationEnd, ActivationStart, BaseRouteReuseStrategy, ChildActivationEnd, ChildActivationStart, ChildrenOutletContexts, 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, UrlHandlingStrategy, UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree, VERSION, convertToParamMap, provideRoutes, ɵEmptyOutletComponent, ROUTER_PROVIDERS as ɵROUTER_PROVIDERS, ROUTER_FORROOT_GUARD as ɵangular_packages_router_router_a, routerNgProbeToken as ɵangular_packages_router_router_b, createRouterScroller as ɵangular_packages_router_router_c, provideLocationStrategy as ɵangular_packages_router_router_d, provideForRootGuard as ɵangular_packages_router_router_e, setupRouter as ɵangular_packages_router_router_f, rootRoute as ɵangular_packages_router_router_g, RouterInitializer as ɵangular_packages_router_router_h, getAppInitializer as ɵangular_packages_router_router_i, getBootstrapListener as ɵangular_packages_router_router_j, provideRouterInitializer as ɵangular_packages_router_router_k, ɵEmptyOutletComponent as ɵangular_packages_router_router_l, Tree as ɵangular_packages_router_router_m, TreeNode as ɵangular_packages_router_router_n, RouterScroller as ɵangular_packages_router_router_o, assignExtraOptionsToRouter as ɵassignExtraOptionsToRouter, flatten as ɵflatten };
-//# sourceMappingURL=router.js.map
+export { ActivatedRoute, ActivatedRouteSnapshot, ActivationEnd, ActivationStart, BaseRouteReuseStrategy, ChildActivationEnd, ChildActivationStart, ChildrenOutletContexts, 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, UrlHandlingStrategy, UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree, VERSION, convertToParamMap, provideRoutes, ɵEmptyOutletComponent, ROUTER_PROVIDERS as ɵROUTER_PROVIDERS, assignExtraOptionsToRouter as ɵassignExtraOptionsToRouter, flatten as ɵflatten };
+//# sourceMappingURL=router.mjs.map