@angular/router 9.1.0 → 9.1.4

package/bundles/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v9.1.0
+ * @license Angular v9.1.4
  * (c) 2010-2020 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -78,10 +78,11 @@
     }
 
     function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
         return new (P || (P = Promise))(function (resolve, reject) {
             function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
             function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-            function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
             step((generator = generator.apply(thisArg, _arguments || [])).next());
         });
     }
@@ -119,14 +120,15 @@
     }
 
     function __values(o) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
         if (m) return m.call(o);
-        return {
+        if (o && typeof o.length === "number") return {
             next: function () {
                 if (o && i >= o.length) o = void 0;
                 return { value: o && o[i++], done: !o };
             }
         };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
     }
 
     function __read(o, n) {
@@ -205,6 +207,21 @@
 
     function __importDefault(mod) {
         return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+
+    function __classPrivateFieldGet(receiver, privateMap) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to get private field on non-instance");
+        }
+        return privateMap.get(receiver);
+    }
+
+    function __classPrivateFieldSet(receiver, privateMap, value) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to set private field on non-instance");
+        }
+        privateMap.set(receiver, value);
+        return value;
     }
 
     /**
@@ -270,7 +287,9 @@
             return _this;
         }
         /** @docsNotRequired */
-        NavigationStart.prototype.toString = function () { return "NavigationStart(id: " + this.id + ", url: '" + this.url + "')"; };
+        NavigationStart.prototype.toString = function () {
+            return "NavigationStart(id: " + this.id + ", url: '" + this.url + "')";
+        };
         return NavigationStart;
     }(RouterEvent));
     /**
@@ -319,7 +338,9 @@
             return _this;
         }
         /** @docsNotRequired */
-        NavigationCancel.prototype.toString = function () { return "NavigationCancel(id: " + this.id + ", url: '" + this.url + "')"; };
+        NavigationCancel.prototype.toString = function () {
+            return "NavigationCancel(id: " + this.id + ", url: '" + this.url + "')";
+        };
         return NavigationCancel;
     }(RouterEvent));
     /**
@@ -495,7 +516,9 @@
         route) {
             this.route = route;
         }
-        RouteConfigLoadStart.prototype.toString = function () { return "RouteConfigLoadStart(path: " + this.route.path + ")"; };
+        RouteConfigLoadStart.prototype.toString = function () {
+            return "RouteConfigLoadStart(path: " + this.route.path + ")";
+        };
         return RouteConfigLoadStart;
     }());
     /**
@@ -509,7 +532,9 @@
         route) {
             this.route = route;
         }
-        RouteConfigLoadEnd.prototype.toString = function () { return "RouteConfigLoadEnd(path: " + this.route.path + ")"; };
+        RouteConfigLoadEnd.prototype.toString = function () {
+            return "RouteConfigLoadEnd(path: " + this.route.path + ")";
+        };
         return RouteConfigLoadEnd;
     }());
     /**
@@ -657,7 +682,9 @@
         function ParamsAsMap(params) {
             this.params = params || {};
         }
-        ParamsAsMap.prototype.has = function (name) { return this.params.hasOwnProperty(name); };
+        ParamsAsMap.prototype.has = function (name) {
+            return this.params.hasOwnProperty(name);
+        };
         ParamsAsMap.prototype.get = function (name) {
             if (this.has(name)) {
                 var v = this.params[name];
@@ -673,7 +700,9 @@
             return [];
         };
         Object.defineProperty(ParamsAsMap.prototype, "keys", {
-            get: function () { return Object.keys(this.params); },
+            get: function () {
+                return Object.keys(this.params);
+            },
             enumerable: true,
             configurable: true
         });
@@ -1060,7 +1089,9 @@
             configurable: true
         });
         /** @docsNotRequired */
-        UrlTree.prototype.toString = function () { return DEFAULT_SERIALIZER.serialize(this); };
+        UrlTree.prototype.toString = function () {
+            return DEFAULT_SERIALIZER.serialize(this);
+        };
         return UrlTree;
     }());
     /**
@@ -1086,15 +1117,21 @@
             forEach(children, function (v, k) { return v.parent = _this; });
         }
         /** Whether the segment has child segments */
-        UrlSegmentGroup.prototype.hasChildren = function () { return this.numberOfChildren > 0; };
+        UrlSegmentGroup.prototype.hasChildren = function () {
+            return this.numberOfChildren > 0;
+        };
         Object.defineProperty(UrlSegmentGroup.prototype, "numberOfChildren", {
             /** Number of child segments */
-            get: function () { return Object.keys(this.children).length; },
+            get: function () {
+                return Object.keys(this.children).length;
+            },
             enumerable: true,
             configurable: true
         });
         /** @docsNotRequired */
-        UrlSegmentGroup.prototype.toString = function () { return serializePaths(this); };
+        UrlSegmentGroup.prototype.toString = function () {
+            return serializePaths(this);
+        };
         return UrlSegmentGroup;
     }());
     /**
@@ -1143,7 +1180,9 @@
             configurable: true
         });
         /** @docsNotRequired */
-        UrlSegment.prototype.toString = function () { return serializePath(this); };
+        UrlSegment.prototype.toString = function () {
+            return serializePath(this);
+        };
         return UrlSegment;
     }());
     function equalSegments(as, bs) {
@@ -1314,7 +1353,7 @@
                 value.map(function (v) { return encodeUriQuery(name) + "=" + encodeUriQuery(v); }).join('&') :
                 encodeUriQuery(name) + "=" + encodeUriQuery(value);
         });
-        return strParams.length ? "?" + strParams.join("&") : '';
+        return strParams.length ? "?" + strParams.join('&') : '';
     }
     var SEGMENT_RE = /^[^\/()?;=#]+/;
     function matchSegments(str) {
@@ -1477,7 +1516,9 @@
             }
             return segments;
         };
-        UrlParser.prototype.peekStartsWith = function (str) { return this.remaining.startsWith(str); };
+        UrlParser.prototype.peekStartsWith = function (str) {
+            return this.remaining.startsWith(str);
+        };
         // Consumes the prefix when it is present and returns whether it has been consumed
         UrlParser.prototype.consumeOptional = function (str) {
             if (this.peekStartsWith(str)) {
@@ -1506,7 +1547,9 @@
             this._root = root;
         }
         Object.defineProperty(Tree.prototype, "root", {
-            get: function () { return this._root.value; },
+            get: function () {
+                return this._root.value;
+            },
             enumerable: true,
             configurable: true
         });
@@ -1544,7 +1587,9 @@
         /**
          * @internal
          */
-        Tree.prototype.pathFromRoot = function (t) { return findPath(t, this._root).map(function (s) { return s.value; }); };
+        Tree.prototype.pathFromRoot = function (t) {
+            return findPath(t, this._root).map(function (s) { return s.value; });
+        };
         return Tree;
     }());
     // DFS for the node matching the value
@@ -1598,7 +1643,9 @@
             this.value = value;
             this.children = children;
         }
-        TreeNode.prototype.toString = function () { return "TreeNode(" + this.value + ")"; };
+        TreeNode.prototype.toString = function () {
+            return "TreeNode(" + this.value + ")";
+        };
         return TreeNode;
     }());
     // Return the list of T indexed by outlet name
@@ -1657,7 +1704,9 @@
             setRouterState(_this, root);
             return _this;
         }
-        RouterState.prototype.toString = function () { return this.snapshot.toString(); };
+        RouterState.prototype.toString = function () {
+            return this.snapshot.toString();
+        };
         return RouterState;
     }(Tree));
     function createEmptyState(urlTree, rootComponent) {
@@ -1718,44 +1767,58 @@
         }
         Object.defineProperty(ActivatedRoute.prototype, "routeConfig", {
             /** The configuration used to match this route. */
-            get: function () { return this._futureSnapshot.routeConfig; },
+            get: function () {
+                return this._futureSnapshot.routeConfig;
+            },
             enumerable: true,
             configurable: true
         });
         Object.defineProperty(ActivatedRoute.prototype, "root", {
             /** The root of the router state. */
-            get: function () { return this._routerState.root; },
+            get: function () {
+                return this._routerState.root;
+            },
             enumerable: true,
             configurable: true
         });
         Object.defineProperty(ActivatedRoute.prototype, "parent", {
             /** The parent of this route in the router state tree. */
-            get: function () { return this._routerState.parent(this); },
+            get: function () {
+                return this._routerState.parent(this);
+            },
             enumerable: true,
             configurable: true
         });
         Object.defineProperty(ActivatedRoute.prototype, "firstChild", {
             /** The first child of this route in the router state tree. */
-            get: function () { return this._routerState.firstChild(this); },
+            get: function () {
+                return this._routerState.firstChild(this);
+            },
             enumerable: true,
             configurable: true
         });
         Object.defineProperty(ActivatedRoute.prototype, "children", {
             /** The children of this route in the router state tree. */
-            get: function () { return this._routerState.children(this); },
+            get: function () {
+                return this._routerState.children(this);
+            },
             enumerable: true,
             configurable: true
         });
         Object.defineProperty(ActivatedRoute.prototype, "pathFromRoot", {
             /** The path from the root of the router state tree to this route. */
-            get: function () { return this._routerState.pathFromRoot(this); },
+            get: function () {
+                return this._routerState.pathFromRoot(this);
+            },
             enumerable: true,
             configurable: true
         });
         Object.defineProperty(ActivatedRoute.prototype, "paramMap", {
-            /** An Observable that contains a map of the required and optional parameters
+            /**
+             * An Observable that contains a map of the required and optional parameters
              * specific to the route.
-             * The map supports retrieving single and multiple values from the same parameter. */
+             * The map supports retrieving single and multiple values from the same parameter.
+             */
             get: function () {
                 if (!this._paramMap) {
                     this._paramMap = this.params.pipe(operators.map(function (p) { return convertToParamMap(p); }));
@@ -1874,31 +1937,41 @@
         }
         Object.defineProperty(ActivatedRouteSnapshot.prototype, "root", {
             /** The root of the router state */
-            get: function () { return this._routerState.root; },
+            get: function () {
+                return this._routerState.root;
+            },
             enumerable: true,
             configurable: true
         });
         Object.defineProperty(ActivatedRouteSnapshot.prototype, "parent", {
             /** The parent of this route in the router state tree */
-            get: function () { return this._routerState.parent(this); },
+            get: function () {
+                return this._routerState.parent(this);
+            },
             enumerable: true,
             configurable: true
         });
         Object.defineProperty(ActivatedRouteSnapshot.prototype, "firstChild", {
             /** The first child of this route in the router state tree */
-            get: function () { return this._routerState.firstChild(this); },
+            get: function () {
+                return this._routerState.firstChild(this);
+            },
             enumerable: true,
             configurable: true
         });
         Object.defineProperty(ActivatedRouteSnapshot.prototype, "children", {
             /** The children of this route in the router state tree */
-            get: function () { return this._routerState.children(this); },
+            get: function () {
+                return this._routerState.children(this);
+            },
             enumerable: true,
             configurable: true
         });
         Object.defineProperty(ActivatedRouteSnapshot.prototype, "pathFromRoot", {
             /** The path from the root of the router state tree to this route */
-            get: function () { return this._routerState.pathFromRoot(this); },
+            get: function () {
+                return this._routerState.pathFromRoot(this);
+            },
             enumerable: true,
             configurable: true
         });
@@ -1967,7 +2040,9 @@
             setRouterState(_this, root);
             return _this;
         }
-        RouterStateSnapshot.prototype.toString = function () { return serializeNode(this._root); };
+        RouterStateSnapshot.prototype.toString = function () {
+            return serializeNode(this._root);
+        };
         return RouterStateSnapshot;
     }(Tree));
     function setRouterState(state, node) {
@@ -3201,13 +3276,13 @@
                     // Toggle pending flag if any values haven't been set yet
                     if (val === INITIAL_VALUE)
                         isPending = true;
-                    // Any other return values are only valid if we haven't yet hit a pending call.
-                    // This guarantees that in the case of a guard at the bottom of the tree that
-                    // returns a redirect, we will wait for the higher priority guard at the top to
-                    // finish before performing the redirect.
+                    // Any other return values are only valid if we haven't yet hit a pending
+                    // call. This guarantees that in the case of a guard at the bottom of the
+                    // tree that returns a redirect, we will wait for the higher priority
+                    // guard at the top to finish before performing the redirect.
                     if (!isPending) {
-                        // Early return when we hit a `false` value as that should always cancel
-                        // navigation
+                        // Early return when we hit a `false` value as that should always
+                        // cancel navigation
                         if (val === false)
                             return val;
                         if (i === list.length - 1 || isUrlTree(val)) {
@@ -3247,7 +3322,9 @@
     function runCanDeactivateChecks(checks, futureRSS, currRSS, moduleInjector) {
         return rxjs.from(checks).pipe(operators.mergeMap(function (check) {
             return runCanDeactivate(check.component, check.route, currRSS, futureRSS, moduleInjector);
-        }), operators.first(function (result) { return result !== true; }, true));
+        }), operators.first(function (result) {
+            return result !== true;
+        }, true));
     }
     function runCanActivateChecks(futureSnapshot, checks, moduleInjector, forwardEvent) {
         return rxjs.from(checks).pipe(operators.concatMap(function (check) {
@@ -3260,16 +3337,18 @@
                 .pipe(operators.concatAll(), operators.first(function (result) {
                 return result !== true;
             }, true));
-        }), operators.first(function (result) { return result !== true; }, true));
+        }), operators.first(function (result) {
+            return result !== true;
+        }, true));
     }
     /**
-       * This should fire off `ActivationStart` events for each route being activated at this
-       * level.
-       * In other words, if you're activating `a` and `b` below, `path` will contain the
-       * `ActivatedRouteSnapshot`s for both and we will fire `ActivationStart` for both. Always
-       * return
-       * `true` so checks continue to run.
-       */
+     * This should fire off `ActivationStart` events for each route being activated at this
+     * level.
+     * In other words, if you're activating `a` and `b` below, `path` will contain the
+     * `ActivatedRouteSnapshot`s for both and we will fire `ActivationStart` for both. Always
+     * return
+     * `true` so checks continue to run.
+     */
     function fireActivationStart(snapshot, forwardEvent) {
         if (snapshot !== null && forwardEvent) {
             forwardEvent(new ActivationStart(snapshot));
@@ -3277,13 +3356,13 @@
         return rxjs.of(true);
     }
     /**
-       * This should fire off `ChildActivationStart` events for each route being activated at this
-       * level.
-       * In other words, if you're activating `a` and `b` below, `path` will contain the
-       * `ActivatedRouteSnapshot`s for both and we will fire `ChildActivationStart` for both. Always
-       * return
-       * `true` so checks continue to run.
-       */
+     * This should fire off `ChildActivationStart` events for each route being activated at this
+     * level.
+     * In other words, if you're activating `a` and `b` below, `path` will contain the
+     * `ActivatedRouteSnapshot`s for both and we will fire `ChildActivationStart` for both. Always
+     * return
+     * `true` so checks continue to run.
+     */
     function fireChildActivationStart(snapshot, forwardEvent) {
         if (snapshot !== null && forwardEvent) {
             forwardEvent(new ChildActivationStart(snapshot));
@@ -3347,8 +3426,7 @@
             var guard = getToken(c, currARS, moduleInjector);
             var observable;
             if (isCanDeactivate(guard)) {
-                observable =
-                    wrapIntoObservable(guard.canDeactivate(component, currARS, currRSS, futureRSS));
+                observable = wrapIntoObservable(guard.canDeactivate(component, currARS, currRSS, futureRSS));
             }
             else if (isFunction(guard)) {
                 observable = wrapIntoObservable(guard(component, currARS, currRSS, futureRSS));
@@ -3514,7 +3592,9 @@
         if (!res)
             throw new NoMatch$1();
         var posParams = {};
-        forEach(res.posParams, function (v, k) { posParams[k] = v.path; });
+        forEach(res.posParams, function (v, k) {
+            posParams[k] = v.path;
+        });
         var parameters = res.consumed.length > 0 ? __assign(__assign({}, posParams), res.consumed[res.consumed.length - 1].parameters) :
             posParams;
         return { consumedSegments: res.consumed, lastChild: res.consumed.length, parameters: parameters };
@@ -3764,10 +3844,16 @@
     var DefaultRouteReuseStrategy = /** @class */ (function () {
         function DefaultRouteReuseStrategy() {
         }
-        DefaultRouteReuseStrategy.prototype.shouldDetach = function (route) { return false; };
+        DefaultRouteReuseStrategy.prototype.shouldDetach = function (route) {
+            return false;
+        };
         DefaultRouteReuseStrategy.prototype.store = function (route, detachedTree) { };
-        DefaultRouteReuseStrategy.prototype.shouldAttach = function (route) { return false; };
-        DefaultRouteReuseStrategy.prototype.retrieve = function (route) { return null; };
+        DefaultRouteReuseStrategy.prototype.shouldAttach = function (route) {
+            return false;
+        };
+        DefaultRouteReuseStrategy.prototype.retrieve = function (route) {
+            return null;
+        };
         DefaultRouteReuseStrategy.prototype.shouldReuseRoute = function (future, curr) {
             return future.routeConfig === curr.routeConfig;
         };
@@ -3852,9 +3938,15 @@
     var DefaultUrlHandlingStrategy = /** @class */ (function () {
         function DefaultUrlHandlingStrategy() {
         }
-        DefaultUrlHandlingStrategy.prototype.shouldProcessUrl = function (url) { return true; };
-        DefaultUrlHandlingStrategy.prototype.extract = function (url) { return url; };
-        DefaultUrlHandlingStrategy.prototype.merge = function (newUrlPart, wholeUrl) { return newUrlPart; };
+        DefaultUrlHandlingStrategy.prototype.shouldProcessUrl = function (url) {
+            return true;
+        };
+        DefaultUrlHandlingStrategy.prototype.extract = function (url) {
+            return url;
+        };
+        DefaultUrlHandlingStrategy.prototype.merge = function (newUrlPart, wholeUrl) {
+            return newUrlPart;
+        };
         return DefaultUrlHandlingStrategy;
     }());
 
@@ -3933,10 +4025,7 @@
              *
              * @internal
              */
-            this.hooks = {
-                beforePreactivation: defaultRouterHook,
-                afterPreactivation: defaultRouterHook
-            };
+            this.hooks = { beforePreactivation: defaultRouterHook, afterPreactivation: defaultRouterHook };
             /**
              * A strategy for extracting and merging URLs.
              * Used for AngularJS to Angular migrations.
@@ -4015,7 +4104,9 @@
             var eventsSubject = this.events;
             return transitions.pipe(operators.filter(function (t) { return t.id !== 0; }), 
             // Extract URL
-            operators.map(function (t) { return (__assign(__assign({}, t), { extractedUrl: _this.urlHandlingStrategy.extract(t.rawUrl) })); }), 
+            operators.map(function (t) {
+                return (__assign(__assign({}, t), { extractedUrl: _this.urlHandlingStrategy.extract(t.rawUrl) }));
+            }), 
             // Using switchMap so we cancel executing navigations when a new one comes in
             operators.switchMap(function (t) {
                 var completed = false;
@@ -4033,7 +4124,8 @@
                             null
                     };
                 }), operators.switchMap(function (t) {
-                    var urlTransition = !_this.navigated || t.extractedUrl.toString() !== _this.browserUrlTree.toString();
+                    var urlTransition = !_this.navigated ||
+                        t.extractedUrl.toString() !== _this.browserUrlTree.toString();
                     var processCurrentUrl = (_this.onSameUrlNavigation === 'reload' ? true : urlTransition) &&
                         _this.urlHandlingStrategy.shouldProcessUrl(t.rawUrl);
                     if (processCurrentUrl) {
@@ -4047,8 +4139,8 @@
                             }
                             return [t];
                         }), 
-                        // This delay is required to match old behavior that forced navigation to
-                        // always be async
+                        // This delay is required to match old behavior that forced navigation
+                        // to always be async
                         operators.switchMap(function (t) { return Promise.resolve(t); }), 
                         // ApplyRedirects
                         applyRedirects$1(_this.ngModule.injector, _this.configLoader, _this.urlSerializer, _this.config), 
@@ -4076,9 +4168,9 @@
                     else {
                         var processPreviousUrl = urlTransition && _this.rawUrlTree &&
                             _this.urlHandlingStrategy.shouldProcessUrl(_this.rawUrlTree);
-                        /* When the current URL shouldn't be processed, but the previous one was, we
-                         * handle this "error condition" by navigating to the previously successful URL,
-                         * but leaving the URL intact.*/
+                        /* When the current URL shouldn't be processed, but the previous one was,
+                         * we handle this "error condition" by navigating to the previously
+                         * successful URL, but leaving the URL intact.*/
                         if (processPreviousUrl) {
                             var id = t.id, extractedUrl = t.extractedUrl, source = t.source, restoredState = t.restoredState, extras = t.extras;
                             var navStart = new NavigationStart(id, _this.serializeUrl(extractedUrl), source, restoredState);
@@ -4087,9 +4179,10 @@
                             return rxjs.of(__assign(__assign({}, t), { targetSnapshot: targetSnapshot, urlAfterRedirects: extractedUrl, extras: __assign(__assign({}, extras), { skipLocationChange: false, replaceUrl: false }) }));
                         }
                         else {
-                            /* When neither the current or previous URL can be processed, do nothing other
-                             * than update router's internal reference to the current "settled" URL. This
-                             * way the next navigation will be coming from the current URL in the browser.
+                            /* When neither the current or previous URL can be processed, do nothing
+                             * other than update router's internal reference to the current "settled"
+                             * URL. This way the next navigation will be coming from the current URL
+                             * in the browser.
                              */
                             _this.rawUrlTree = t.rawUrl;
                             _this.browserUrlTree = t.urlAfterRedirects;
@@ -4160,14 +4253,15 @@
                     var targetRouterState = createRouterState(_this.routeReuseStrategy, t.targetSnapshot, t.currentRouterState);
                     return (__assign(__assign({}, t), { targetRouterState: targetRouterState }));
                 }), 
-                /* Once here, we are about to activate syncronously. The assumption is this will
-                   succeed, and user code may read from the Router service. Therefore before
-                   activation, we need to update router properties storing the current URL and the
-                   RouterState, as well as updated the browser URL. All this should happen *before*
-                   activating. */
+                /* Once here, we are about to activate syncronously. The assumption is this
+                   will succeed, and user code may read from the Router service. Therefore
+                   before activation, we need to update router properties storing the current
+                   URL and the RouterState, as well as updated the browser URL. All this should
+                   happen *before* activating. */
                 operators.tap(function (t) {
                     _this.currentUrlTree = t.urlAfterRedirects;
-                    _this.rawUrlTree = _this.urlHandlingStrategy.merge(_this.currentUrlTree, t.rawUrl);
+                    _this.rawUrlTree =
+                        _this.urlHandlingStrategy.merge(_this.currentUrlTree, t.rawUrl);
                     _this.routerState = t.targetRouterState;
                     if (_this.urlUpdateStrategy === 'deferred') {
                         if (!t.extras.skipLocationChange) {
@@ -4175,40 +4269,50 @@
                         }
                         _this.browserUrlTree = t.urlAfterRedirects;
                     }
-                }), activateRoutes(_this.rootContexts, _this.routeReuseStrategy, function (evt) { return _this.triggerEvent(evt); }), operators.tap({ next: function () { completed = true; }, complete: function () { completed = true; } }), operators.finalize(function () {
-                    /* When the navigation stream finishes either through error or success, we set the
-                     * `completed` or `errored` flag. However, there are some situations where we could
-                     * get here without either of those being set. For instance, a redirect during
-                     * NavigationStart. Therefore, this is a catch-all to make sure the NavigationCancel
-                     * event is fired when a navigation gets cancelled but not caught by other means. */
+                }), activateRoutes(_this.rootContexts, _this.routeReuseStrategy, function (evt) { return _this.triggerEvent(evt); }), operators.tap({
+                    next: function () {
+                        completed = true;
+                    },
+                    complete: function () {
+                        completed = true;
+                    }
+                }), operators.finalize(function () {
+                    /* When the navigation stream finishes either through error or success, we
+                     * set the `completed` or `errored` flag. However, there are some situations
+                     * where we could get here without either of those being set. For instance, a
+                     * redirect during NavigationStart. Therefore, this is a catch-all to make
+                     * sure the NavigationCancel
+                     * event is fired when a navigation gets cancelled but not caught by other
+                     * means. */
                     if (!completed && !errored) {
-                        // 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 Angualr router.
+                        // 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 Angualr
+                        // router.
                         _this.resetUrlToCurrentUrlTree();
                         var navCancel = new NavigationCancel(t.id, _this.serializeUrl(t.extractedUrl), "Navigation ID " + t.id + " is not equal to the current navigation id " + _this.navigationId);
                         eventsSubject.next(navCancel);
                         t.resolve(false);
                     }
                     // 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.
+                    // successful, lastSuccessfulTransition will have already been set. Therefore
+                    // we can safely set currentNavigation to null here.
                     _this.currentNavigation = null;
                 }), operators.catchError(function (e) {
                     errored = true;
-                    /* This error type is issued during Redirect, and is handled as a cancellation
-                     * rather than an error. */
+                    /* This error type is issued during Redirect, and is handled as a
+                     * cancellation rather than an error. */
                     if (isNavigationCancelingError(e)) {
                         var redirecting = isUrlTree(e.url);
                         if (!redirecting) {
                             // Set property only if we're not redirecting. If we landed on a page and
-                            // redirect to `/` route, the new navigation is going to see the `/` isn't
-                            // a change from the default currentUrlTree and won't navigate. This is
-                            // only applicable with initial navigation, so setting `navigated` only when
-                            // not redirecting resolves this scenario.
+                            // redirect to `/` route, the new navigation is going to see the `/`
+                            // isn't a change from the default currentUrlTree and won't navigate.
+                            // This is only applicable with initial navigation, so setting
+                            // `navigated` only when not redirecting resolves this scenario.
                             _this.navigated = true;
                             _this.resetStateAndUrl(t.currentRouterState, t.currentUrlTree, t.rawUrl);
                         }
@@ -4233,8 +4337,8 @@
                                 return _this.scheduleNavigation(mergedTree, 'imperative', null, extras, { resolve: t.resolve, reject: t.reject, promise: t.promise });
                             }, 0);
                         }
-                        /* All other errors should reset to the router's internal URL reference to the
-                         * pre-error state. */
+                        /* All other errors should reset to the router's internal URL reference to
+                         * the pre-error state. */
                     }
                     else {
                         _this.resetStateAndUrl(t.currentRouterState, t.currentUrlTree, t.rawUrl);
@@ -4297,20 +4401,28 @@
                     // Navigations coming from Angular router have a navigationId state property. When this
                     // exists, restore the state.
                     var state = change.state && change.state.navigationId ? change.state : null;
-                    setTimeout(function () { _this.scheduleNavigation(rawUrlTree, source, state, { replaceUrl: true }); }, 0);
+                    setTimeout(function () {
+                        _this.scheduleNavigation(rawUrlTree, source, state, { replaceUrl: true });
+                    }, 0);
                 });
             }
         };
         Object.defineProperty(Router.prototype, "url", {
             /** The current URL. */
-            get: function () { return this.serializeUrl(this.currentUrlTree); },
+            get: function () {
+                return this.serializeUrl(this.currentUrlTree);
+            },
             enumerable: true,
             configurable: true
         });
         /** The current Navigation object if one exists */
-        Router.prototype.getCurrentNavigation = function () { return this.currentNavigation; };
+        Router.prototype.getCurrentNavigation = function () {
+            return this.currentNavigation;
+        };
         /** @internal */
-        Router.prototype.triggerEvent = function (event) { this.events.next(event); };
+        Router.prototype.triggerEvent = function (event) {
+            this.events.next(event);
+        };
         /**
          * Resets the configuration used for navigation and generating links.
          *
@@ -4334,7 +4446,9 @@
             this.lastSuccessfulId = -1;
         };
         /** @docsNotRequired */
-        Router.prototype.ngOnDestroy = function () { this.dispose(); };
+        Router.prototype.ngOnDestroy = function () {
+            this.dispose();
+        };
         /** Disposes of the router. */
         Router.prototype.dispose = function () {
             if (this.locationSubscription) {
@@ -4479,7 +4593,9 @@
             return this.navigateByUrl(this.createUrlTree(commands, extras), extras);
         };
         /** Serializes a `UrlTree` into a string */
-        Router.prototype.serializeUrl = function (url) { return this.urlSerializer.serialize(url); };
+        Router.prototype.serializeUrl = function (url) {
+            return this.urlSerializer.serialize(url);
+        };
         /** Parses a string into a `UrlTree` */
         Router.prototype.parseUrl = function (url) {
             var urlTree;
@@ -4518,7 +4634,9 @@
                 _this.lastSuccessfulNavigation = _this.currentNavigation;
                 _this.currentNavigation = null;
                 t.resolve(true);
-            }, function (e) { _this.console.warn("Unhandled Navigation Error: "); });
+            }, function (e) {
+                _this.console.warn("Unhandled Navigation Error: ");
+            });
         };
         Router.prototype.scheduleNavigation = function (rawUrl, source, restoredState, extras, priorPromise) {
             var lastNavigation = this.getTransition();
@@ -4563,13 +4681,20 @@
                 source: source,
                 restoredState: restoredState,
                 currentUrlTree: this.currentUrlTree,
-                currentRawUrl: this.rawUrlTree, rawUrl: rawUrl, extras: extras, resolve: resolve, reject: reject, promise: promise,
+                currentRawUrl: this.rawUrlTree,
+                rawUrl: rawUrl,
+                extras: extras,
+                resolve: resolve,
+                reject: reject,
+                promise: promise,
                 currentSnapshot: this.routerState.snapshot,
                 currentRouterState: this.routerState
             });
             // Make sure that the error is propagated even though `processNavigations` catch
             // handler does not rethrow
-            return promise.catch(function (e) { return Promise.reject(e); });
+            return promise.catch(function (e) {
+                return Promise.reject(e);
+            });
         };
         Router.prototype.setBrowserUrl = function (url, replaceUrl, id, state) {
             var path = this.urlSerializer.serialize(url);
@@ -4741,6 +4866,7 @@
             var extras = {
                 skipLocationChange: attrBoolValue(this.skipLocationChange),
                 replaceUrl: attrBoolValue(this.replaceUrl),
+                state: this.state,
             };
             this.router.navigateByUrl(this.urlTree, extras);
             return true;
@@ -4856,8 +4982,12 @@
             enumerable: true,
             configurable: true
         });
-        RouterLinkWithHref.prototype.ngOnChanges = function (changes) { this.updateTargetUrlAndHref(); };
-        RouterLinkWithHref.prototype.ngOnDestroy = function () { this.subscription.unsubscribe(); };
+        RouterLinkWithHref.prototype.ngOnChanges = function (changes) {
+            this.updateTargetUrlAndHref();
+        };
+        RouterLinkWithHref.prototype.ngOnDestroy = function () {
+            this.subscription.unsubscribe();
+        };
         RouterLinkWithHref.prototype.onClick = function (button, ctrlKey, metaKey, shiftKey) {
             if (button !== 0 || ctrlKey || metaKey || shiftKey) {
                 return true;
@@ -5048,8 +5178,12 @@
             enumerable: true,
             configurable: true
         });
-        RouterLinkActive.prototype.ngOnChanges = function (changes) { this.update(); };
-        RouterLinkActive.prototype.ngOnDestroy = function () { this.subscription.unsubscribe(); };
+        RouterLinkActive.prototype.ngOnChanges = function (changes) {
+            this.update();
+        };
+        RouterLinkActive.prototype.ngOnDestroy = function () {
+            this.subscription.unsubscribe();
+        };
         RouterLinkActive.prototype.update = function () {
             var _this = this;
             if (!this.links || !this.linksWithHrefs || !this.router.navigated)
@@ -5170,7 +5304,9 @@
             this.contexts = new Map();
             return contexts;
         };
-        ChildrenOutletContexts.prototype.onOutletReAttached = function (contexts) { this.contexts = contexts; };
+        ChildrenOutletContexts.prototype.onOutletReAttached = function (contexts) {
+            this.contexts = contexts;
+        };
         ChildrenOutletContexts.prototype.getOrCreateContext = function (childName) {
             var context = this.getContext(childName);
             if (!context) {
@@ -5179,7 +5315,9 @@
             }
             return context;
         };
-        ChildrenOutletContexts.prototype.getContext = function (childName) { return this.contexts.get(childName) || null; };
+        ChildrenOutletContexts.prototype.getContext = function (childName) {
+            return this.contexts.get(childName) || null;
+        };
         return ChildrenOutletContexts;
     }());
 
@@ -5229,7 +5367,9 @@
             this.name = name || PRIMARY_OUTLET;
             parentContexts.onChildOutletCreated(this.name, this);
         }
-        RouterOutlet.prototype.ngOnDestroy = function () { this.parentContexts.onChildOutletDestroyed(this.name); };
+        RouterOutlet.prototype.ngOnDestroy = function () {
+            this.parentContexts.onChildOutletDestroyed(this.name);
+        };
         RouterOutlet.prototype.ngOnInit = function () {
             if (!this.activated) {
                 // If the outlet was not instantiated at the time the route got activated we need to populate
@@ -5248,7 +5388,9 @@
             }
         };
         Object.defineProperty(RouterOutlet.prototype, "isActivated", {
-            get: function () { return !!this.activated; },
+            get: function () {
+                return !!this.activated;
+            },
             enumerable: true,
             configurable: true
         });
@@ -5361,12 +5503,12 @@
     }());
 
     /**
-    *@license
-    *Copyright Google Inc. 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
-    */
+     *@license
+     *Copyright Google Inc. 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
      *
@@ -5410,7 +5552,9 @@
     var NoPreloading = /** @class */ (function () {
         function NoPreloading() {
         }
-        NoPreloading.prototype.preload = function (route, fn) { return rxjs.of(null); };
+        NoPreloading.prototype.preload = function (route, fn) {
+            return rxjs.of(null);
+        };
         return NoPreloading;
     }());
     /**
@@ -5448,7 +5592,9 @@
         // TODO(jasonaden): This class relies on code external to the class to call setUpPreloading. If
         // this hasn't been done, ngOnDestroy will fail as this.subscription will be undefined. This
         // should be refactored.
-        RouterPreloader.prototype.ngOnDestroy = function () { this.subscription.unsubscribe(); };
+        RouterPreloader.prototype.ngOnDestroy = function () {
+            this.subscription.unsubscribe();
+        };
         RouterPreloader.prototype.processRoutes = function (ngModule, routes) {
             var e_1, _a;
             var res = [];
@@ -5691,7 +5837,7 @@
          * @param routes An array of `Route` objects that define the navigation paths for the application.
          * @param config An `ExtraOptions` configuration object that controls how navigation is performed.
          * @return The new router module.
-        */
+         */
         RouterModule.forRoot = function (routes, config) {
             return {
                 ngModule: RouterModule_1,
@@ -5707,9 +5853,7 @@
                     {
                         provide: common.LocationStrategy,
                         useFactory: provideLocationStrategy,
-                        deps: [
-                            common.PlatformLocation, [new core.Inject(common.APP_BASE_HREF), new core.Optional()], ROUTER_CONFIGURATION
-                        ]
+                        deps: [common.PlatformLocation, [new core.Inject(common.APP_BASE_HREF), new core.Optional()], ROUTER_CONFIGURATION]
                     },
                     {
                         provide: RouterScroller,
@@ -5948,7 +6092,7 @@
     /**
      * @publicApi
      */
-    var VERSION = new core.Version('9.1.0');
+    var VERSION = new core.Version('9.1.4');
 
     /**
      * @license