@angular/router 13.0.0-next.7 → 13.0.0-rc.1

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

@@ -1,13 +1,15 @@
 /**
- * @license Angular v13.0.0-next.7
+ * @license Angular v13.0.0-rc.1
  * (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, EventEmitter, ChangeDetectorRef, Optional, ContentChildren, Output, ViewContainerRef, ComponentFactoryResolver, 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
@@ -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-rc.1", 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-rc.1", 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-rc.1", 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-rc.1", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ɵEmptyOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0-rc.1", 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-rc.1", 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,127 +3946,49 @@ 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;
-    }
-    load(parentInjector, route) {
-        if (route._loader$) {
-            return route._loader$;
-        }
-        if (this.onLoadStartListener) {
-            this.onLoadStartListener(route);
-        }
-        const moduleFactory$ = this.loadModuleFactory(route.loadChildren);
-        const loadRunner = moduleFactory$.pipe(map((factory) => {
-            if (this.onLoadEndListener) {
-                this.onLoadEndListener(route);
-            }
-            const module = factory.create(parentInjector);
-            // When loading a module that doesn't provide `RouterModule.forChild()` preloader
-            // will get stuck in an infinite loop. The child module's Injector will look to
-            // its parent `Injector` when it doesn't find any ROUTES so it will return routes
-            // for it's parent module instead.
-            return new LoadedRouterConfig(flatten(module.injector.get(ROUTES, undefined, InjectFlags.Self | InjectFlags.Optional))
-                .map(standardizeConfig), module);
-        }), catchError((err) => {
-            route._loader$ = undefined;
-            throw err;
-        }));
-        // Use custom ConnectableObservable as share in runners pipe increasing the bundle size too much
-        route._loader$ = new ConnectableObservable(loadRunner, () => new Subject())
-            .pipe(refCount());
-        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);
+    }
+    load(parentInjector, route) {
+        if (route._loader$) {
+            return route._loader$;
         }
-        return context;
+        if (this.onLoadStartListener) {
+            this.onLoadStartListener(route);
+        }
+        const moduleFactory$ = this.loadModuleFactory(route.loadChildren);
+        const loadRunner = moduleFactory$.pipe(map((factory) => {
+            if (this.onLoadEndListener) {
+                this.onLoadEndListener(route);
+            }
+            const module = factory.create(parentInjector);
+            // When loading a module that doesn't provide `RouterModule.forChild()` preloader
+            // will get stuck in an infinite loop. The child module's Injector will look to
+            // its parent `Injector` when it doesn't find any ROUTES so it will return routes
+            // for it's parent module instead.
+            return new LoadedRouterConfig(flatten(module.injector.get(ROUTES, undefined, InjectFlags.Self | InjectFlags.Optional))
+                .map(standardizeConfig), module);
+        }), catchError((err) => {
+            route._loader$ = undefined;
+            throw err;
+        }));
+        // Use custom ConnectableObservable as share in runners pipe increasing the bundle size too much
+        route._loader$ = new ConnectableObservable(loadRunner, () => new Subject())
+            .pipe(refCount());
+        return route._loader$;
     }
-    getContext(childName) {
-        return this.contexts.get(childName) || null;
+    loadModuleFactory(loadChildren) {
+        return wrapIntoObservable(loadChildren()).pipe(mergeMap((t) => {
+            if (t instanceof NgModuleFactory) {
+                return of(t);
+            }
+            else {
+                return from(this.compiler.compileModuleAsync(t));
+            }
+        }));
     }
 }
 
@@ -3807,13 +4023,6 @@ class DefaultUrlHandlingStrategy {
     }
 }
 
-/**
- * @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;
 }
@@ -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;
@@ -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,
@@ -4077,14 +4286,14 @@ 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') {
@@ -4217,6 +4426,7 @@ class Router {
                     completed = true;
                 }
             }), finalize(() => {
+                var _a;
                 /* When the navigation stream finishes either through error or success, we
                  * set the `completed` or `errored` flag. However, there are some situations
                  * where we could get here without either of those being set. For instance, a
@@ -4228,10 +4438,11 @@ class Router {
                     const cancelationReason = `Navigation ID ${t.id} is not equal to the current navigation id ${this.navigationId}`;
                     this.cancelNavigationTransition(t, cancelationReason);
                 }
-                // currentNavigation should always be reset to null here. If navigation was
-                // successful, lastSuccessfulTransition will have already been set. Therefore
-                // we can safely set currentNavigation to null here.
-                this.currentNavigation = null;
+                // Only clear current navigation if it is still set to the one that
+                // finalized.
+                if (((_a = this.currentNavigation) === null || _a === void 0 ? void 0 : _a.id) === t.id) {
+                    this.currentNavigation = null;
+                }
             }), catchError((e) => {
                 // TODO(atscott): The NavigationTransition `t` used here does not accurately
                 // reflect the current state of the whole transition because some operations
@@ -4256,7 +4467,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);
@@ -4288,7 +4499,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 {
@@ -4607,26 +4818,18 @@ class Router {
         if (this.disposed) {
             return Promise.resolve(false);
         }
-        // * 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.
+        // Duplicate navigations may be triggered by attempts to sync AngularJS and
+        // Angular router states. We have the setTimeout in the location listener to
+        // ensure the imperative nav is scheduled before the browser nav.
         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 = 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 :
-            ((_a = lastNavigation.urlAfterRedirects) !== null && _a !== void 0 ? _a : this.browserUrlTree);
-        const duplicateNav = lastNavigationUrl.toString() === rawUrl.toString();
-        if (browserNavPrecededByRouterNav && duplicateNav) {
+        const navToSameUrl = lastNavigation.rawUrl.toString() === rawUrl.toString();
+        const lastNavigationInProgress = lastNavigation.id === ((_a = this.currentNavigation) === null || _a === void 0 ? void 0 : _a.id);
+        // We consider duplicates as ones that goes to the same URL while the first
+        // is still processing.
+        const isDuplicateNav = navToSameUrl && lastNavigationInProgress;
+        if (browserNavPrecededByRouterNav && isDuplicateNav) {
             return Promise.resolve(true); // return value is not used
         }
         let resolve;
@@ -4706,7 +4909,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;
@@ -4728,7 +4931,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
@@ -4736,14 +4938,7 @@ 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) {
@@ -4755,6 +4950,7 @@ class Router {
         // 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));
@@ -4771,19 +4967,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-rc.1", ngImport: i0, type: Router, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+Router.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: Router });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.1", 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];
@@ -4796,13 +4984,6 @@ 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
  *
@@ -4980,28 +5161,38 @@ class RouterLink {
         });
     }
 }
-RouterLink.decorators = [
-    { type: Directive, args: [{ selector: ':not(a):not(area)[routerLink]' },] }
-];
-RouterLink.ctorParameters = () => [
-    { type: Router },
-    { type: ActivatedRoute },
-    { type: undefined, 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-rc.1", 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-rc.1", 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-rc.1", 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
  *
@@ -5091,29 +5282,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, args: ['attr.href',] }],
-    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-rc.1", 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-rc.1", 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-rc.1", 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;
 }
@@ -5294,27 +5498,33 @@ 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 }],
-    isActiveChange: [{ type: Output }],
-    routerLinkActive: [{ type: Input }]
-};
+RouterLinkActive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.1", 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-rc.1", 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-rc.1", 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
+            }] } });
 /**
  * Use instead of `'paths' in options` to be compatible with property renaming
  */
@@ -5322,195 +5532,6 @@ function isActiveMatchOptions(options) {
     return !!options.paths;
 }
 
-/**
- * @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,
- * 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
- */
-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);
-    }
-}
-
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -5570,13 +5591,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 =
@@ -5624,24 +5645,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-rc.1", 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-rc.1", ngImport: i0, type: RouterPreloader });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.1", 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 = {}) {
@@ -5717,14 +5726,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-rc.1", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+RouterScroller.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: RouterScroller });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: RouterScroller, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: Router }, { type: i3.ViewportScroller }, { type: undefined }]; } });
 
 /**
  * @license
@@ -5747,7 +5753,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 },
@@ -5755,18 +5760,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);
@@ -5865,17 +5869,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-rc.1", 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-rc.1", 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-rc.1", ngImport: i0, type: RouterModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.1", 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);
@@ -5914,8 +5927,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;
     }
@@ -5955,6 +5968,9 @@ function assignExtraOptionsToRouter(opts, router) {
     if (opts.urlUpdateStrategy) {
         router.urlUpdateStrategy = opts.urlUpdateStrategy;
     }
+    if (opts.canceledNavigationResolution) {
+        router.canceledNavigationResolution = opts.canceledNavigationResolution;
+    }
 }
 function rootRoute(router) {
     return router.routerState.root;
@@ -6038,12 +6054,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-rc.1", ngImport: i0, type: RouterInitializer, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterInitializer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: RouterInitializer });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.1", ngImport: i0, type: RouterInitializer, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 function getAppInitializer(r) {
     return r.appInitializer.bind(r);
 }
@@ -6081,7 +6096,7 @@ function provideRouterInitializer() {
 /**
  * @publicApi
  */
-const VERSION = new Version('13.0.0-next.7');
+const VERSION = new Version('13.0.0-rc.1');
 
 /**
  * @license
@@ -6120,5 +6135,5 @@ const VERSION = new Version('13.0.0-next.7');
  * 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