\\r\\n\"\r\n }] }\r\n ];\r\n /** @nocollapse */\r\n FilterMarketSwitchComponent.ctorParameters = function () { return [\r\n { type: ElementRef },\r\n { type: Renderer2 }\r\n ]; };\r\n FilterMarketSwitchComponent.propDecorators = {\r\n tooltip: [{ type: Input }],\r\n filter: [{ type: Input }],\r\n inputSelect: [{ type: ViewChild, args: ['inputSelect',] }],\r\n filterChanges: [{ type: Output }]\r\n };\r\n return FilterMarketSwitchComponent;\r\n}(TerrificOnInit));\r\nexport { FilterMarketSwitchComponent };\r\n//# sourceMappingURL=filter-market-switch.component.js.map","/** PURE_IMPORTS_START _isArray PURE_IMPORTS_END */\nimport { isArray } from './isArray';\nexport function isNumeric(val) {\n return !isArray(val) && (val - parseFloat(val) + 1) >= 0;\n}\n//# sourceMappingURL=isNumeric.js.map\n","import * as tslib_1 from \"tslib\";\r\nimport { TerrificOnInit } from '../../../helpers/angular-terrific-on-init/terrific-on-init';\r\nimport { Component, ElementRef, EventEmitter, Input, Output, Renderer2, ViewChild } from '@angular/core';\r\nvar FilterCategorySearchSingleLevelComponent = /** @class */ (function (_super) {\r\n tslib_1.__extends(FilterCategorySearchSingleLevelComponent, _super);\r\n /**\r\n * constructor\r\n * @param elementRef\r\n * @type ElementRef\r\n * @description Injects a reference to the rendered element in DOM\r\n *\r\n */\r\n function FilterCategorySearchSingleLevelComponent(renderer) {\r\n var _this = _super.call(this, renderer) || this;\r\n _this.renderer = renderer;\r\n /**\r\n * @type KEY_ENTER_CODE - A reference to the Enter Key {keyCode} property regarding IE\r\n */\r\n _this.KEY_UP_CODE = 38;\r\n _this.KEY_DOWN_CODE = 40;\r\n _this.KEY_ENTER_CODE = 13;\r\n _this.KEY_ESC_CODE = 27;\r\n _this.filterChanges = new EventEmitter();\r\n return _this;\r\n }\r\n Object.defineProperty(FilterCategorySearchSingleLevelComponent.prototype, \"searchText\", {\r\n get: function () {\r\n return this._searchText;\r\n },\r\n set: function (value) {\r\n this._searchText = value;\r\n },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n /**\r\n * Lifecycle Hook\r\n */\r\n FilterCategorySearchSingleLevelComponent.prototype.ngOnInit = function () {\r\n this._dropdownFilter = JSON.parse(JSON.stringify(this.filter));\r\n };\r\n /**\r\n * onKeyUp {function} - Fires keyUp events when typing in search input field\r\n * @param {KeyboardEvent} event - indicates whether Enter or NumpadEnter is pressed\r\n */\r\n FilterCategorySearchSingleLevelComponent.prototype.onKeyUp = function (event) {\r\n var keyCode = window.event ? event.which : event.keyCode;\r\n if (keyCode === this.KEY_ESC_CODE) {\r\n this.handleKeyEsc();\r\n }\r\n else if (keyCode === this.KEY_ENTER_CODE) {\r\n this.handleKeyEnter();\r\n }\r\n else if (keyCode === this.KEY_DOWN_CODE || keyCode === this.KEY_UP_CODE) {\r\n if (this._searchText && this._searchText.length > 0) {\r\n this.inputChanged();\r\n }\r\n }\r\n else {\r\n if (this._searchText && this._searchText.length > 0) {\r\n this.isFocused = true;\r\n this.inputChanged();\r\n }\r\n }\r\n };\r\n FilterCategorySearchSingleLevelComponent.prototype.onClickSearch = function () {\r\n this.onFocusSearchInput(1);\r\n };\r\n FilterCategorySearchSingleLevelComponent.prototype.onFocusSearchInput = function (delay) {\r\n var _this = this;\r\n setTimeout(function () {\r\n _this.searchInput.nativeElement.focus();\r\n }, delay);\r\n };\r\n FilterCategorySearchSingleLevelComponent.prototype.handleKeyEsc = function () {\r\n this.isFocused = false;\r\n this.inputChanged();\r\n };\r\n FilterCategorySearchSingleLevelComponent.prototype.handleKeyEnter = function () {\r\n this.isFocused = false;\r\n this.setFilters();\r\n };\r\n /**\r\n * when select/unselect a filter, trigger the filterChanges event to search again\r\n */\r\n FilterCategorySearchSingleLevelComponent.prototype.onSelectFilter = function (event, filterValue) {\r\n event.preventDefault();\r\n event.stopPropagation();\r\n if (filterValue && !filterValue.disabled) {\r\n filterValue.checked = !filterValue.checked;\r\n this.setFilters();\r\n this.filterChanges.emit(this.filter);\r\n }\r\n };\r\n Object.defineProperty(FilterCategorySearchSingleLevelComponent.prototype, \"dropdownFilter\", {\r\n get: function () {\r\n return this._dropdownFilter;\r\n },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n Object.defineProperty(FilterCategorySearchSingleLevelComponent.prototype, \"isFocused\", {\r\n get: function () {\r\n return this._isFocused;\r\n },\r\n /**\r\n * when focus leave the input, update this.filter\r\n * when focus on input, refresh dropdown from this.filter\r\n */\r\n set: function (isFocused) {\r\n this._isFocused = isFocused;\r\n if (isFocused === false) {\r\n this.setFilters();\r\n }\r\n else {\r\n this.inputChanged();\r\n }\r\n },\r\n enumerable: true,\r\n configurable: true\r\n });\r\n FilterCategorySearchSingleLevelComponent.prototype.getDropdownClass = function () {\r\n return 'm-filter-categorysearch__dropdown m-filter-categorysearch__dropdown' + ((this.isFocused && this._searchText && this._searchText.length > 0) ? '--is-opened' : '--is-closed');\r\n };\r\n /**\r\n * inputChanged {function} - input changes\r\n * update the dropdown list\r\n */\r\n FilterCategorySearchSingleLevelComponent.prototype.inputChanged = function () {\r\n var _this = this;\r\n if (this._searchText !== undefined) {\r\n this._dropdownFilter = JSON.parse(JSON.stringify(this.filter));\r\n var values = this._dropdownFilter.values.filter(function (val) { return !val.disabled && val.name.toLowerCase().includes(_this.searchText.toLowerCase()); });\r\n this._dropdownFilter.values = values;\r\n }\r\n };\r\n /**\r\n * update check status of this.filter from dropdownlist\r\n */\r\n FilterCategorySearchSingleLevelComponent.prototype.setFilters = function () {\r\n var _this = this;\r\n var toValue;\r\n if (this._dropdownFilter.values && this._dropdownFilter.values.length > 0) {\r\n this._dropdownFilter.values.forEach(function (val) {\r\n if (!val.disabled) {\r\n toValue = _this.filter.values.find(function (item) {\r\n return item.name === val.name;\r\n });\r\n if (toValue) {\r\n toValue.checked = val.checked;\r\n }\r\n }\r\n });\r\n }\r\n };\r\n FilterCategorySearchSingleLevelComponent.prototype.onTerrificBootstrap = function () {\r\n var FilterCategorysearchSingleLevel = this.filterCategorysearchSingleLevelElementRef.nativeElement;\r\n this.renderer.setAttribute(FilterCategorysearchSingleLevel, 'data-t-name', 'FilterCategorysearchSingleLevel');\r\n this.terrific.startNode(FilterCategorysearchSingleLevel);\r\n this.terrificProductFilter = this.getTerrificModule();\r\n };\r\n FilterCategorySearchSingleLevelComponent.prototype.ngOnDestroy = function () {\r\n // this.terrific.stopNode(this.filterCategorysearchSingleLevelElementRef.nativeElement);\r\n };\r\n FilterCategorySearchSingleLevelComponent.prototype.getTerrificModule = function () {\r\n return this.terrific.getModuleByDomNode(this.filterCategorysearchSingleLevelElementRef.nativeElement);\r\n };\r\n FilterCategorySearchSingleLevelComponent.decorators = [\r\n { type: Component, args: [{\r\n selector: 'cov-filter-categorysearch-singlelevel',\r\n template: \"
\\r\\n
\\r\\n
\\r\\n \\r\\n
\\r\\n \\r\\n
\\r\\n\\r\\n
\\r\\n
\\r\\n \\r\\n
{{noResultText}}
\\r\\n \\r\\n \\r\\n
\\r\\n
\\r\\n \\r\\n \\r\\n \\r\\n
\\r\\n
\\r\\n \\r\\n
\\r\\n\"\r\n }] }\r\n ];\r\n /** @nocollapse */\r\n FilterCategorySearchSingleLevelComponent.ctorParameters = function () { return [\r\n { type: Renderer2 }\r\n ]; };\r\n FilterCategorySearchSingleLevelComponent.propDecorators = {\r\n filter: [{ type: Input }],\r\n filterChanges: [{ type: Output }],\r\n noResultText: [{ type: Input }],\r\n searchText: [{ type: Input }],\r\n filterCategorysearchSingleLevelElementRef: [{ type: ViewChild, args: ['filterCategorysearchSingleLevel',] }],\r\n searchInput: [{ type: ViewChild, args: ['searchInput',] }]\r\n };\r\n return FilterCategorySearchSingleLevelComponent;\r\n}(TerrificOnInit));\r\nexport { FilterCategorySearchSingleLevelComponent };\r\n//# sourceMappingURL=filter-categorysearch-singlelevel.component.js.map","/**\n * @license Angular v6.1.7\n * (c) 2010-2018 Google, Inc. https://angular.io/\n * License: MIT\n */\n\nimport { __values, __assign, __extends, __spread } from 'tslib';\nimport { Component, ɵisObservable, ɵisPromise, NgModuleRef, InjectionToken, NgModuleFactory, NgZone, isDevMode, ɵConsole, Attribute, Directive, ElementRef, HostBinding, HostListener, Input, Renderer2, ChangeDetectorRef, ContentChildren, ComponentFactoryResolver, EventEmitter, Output, ViewContainerRef, Compiler, Injectable, Injector, NgModuleFactoryLoader, ANALYZE_FOR_ENTRY_COMPONENTS, APP_BOOTSTRAP_LISTENER, APP_INITIALIZER, ApplicationRef, Inject, NgModule, NgProbeToken, Optional, SkipSelf, SystemJsNgModuleLoader, Version } from '@angular/core';\nimport { from, of, EmptyError, Observable, BehaviorSubject, Subject } from 'rxjs';\nimport { concatAll, every, last, map, mergeAll, catchError, first, mergeMap, concatMap, reduce, filter } from 'rxjs/operators';\nimport { LocationStrategy, APP_BASE_HREF, HashLocationStrategy, LOCATION_INITIALIZED, Location, PathLocationStrategy, PlatformLocation, ViewportScroller } from '@angular/common';\nimport { ɵgetDOM } from '@angular/platform-browser';\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n *\n * Base for events the Router goes through, as opposed to events tied to a specific\n * Route. `RouterEvent`s will only be fired one time for any given navigation.\n *\n * Example:\n *\n * ```\n * class MyService {\n * constructor(public router: Router, logger: Logger) {\n * router.events.filter(e => e instanceof RouterEvent).subscribe(e => {\n * logger.log(e.id, e.url);\n * });\n * }\n * }\n * ```\n *\n * @experimental\n */\nvar RouterEvent = /** @class */ (function () {\n function RouterEvent(\n /** @docsNotRequired */\n id, \n /** @docsNotRequired */\n url) {\n this.id = id;\n this.url = url;\n }\n return RouterEvent;\n}());\n/**\n * @description\n *\n * Represents an event triggered when a navigation starts.\n *\n *\n */\nvar NavigationStart = /** @class */ (function (_super) {\n __extends(NavigationStart, _super);\n function NavigationStart(\n /** @docsNotRequired */\n id, \n /** @docsNotRequired */\n url, \n /** @docsNotRequired */\n navigationTrigger, \n /** @docsNotRequired */\n restoredState) {\n if (navigationTrigger === void 0) { \n /** @docsNotRequired */\n navigationTrigger = 'imperative'; }\n if (restoredState === void 0) { \n /** @docsNotRequired */\n restoredState = null; }\n var _this = _super.call(this, id, url) || this;\n _this.navigationTrigger = navigationTrigger;\n _this.restoredState = restoredState;\n return _this;\n }\n /** @docsNotRequired */\n NavigationStart.prototype.toString = function () { return \"NavigationStart(id: \" + this.id + \", url: '\" + this.url + \"')\"; };\n return NavigationStart;\n}(RouterEvent));\n/**\n * @description\n *\n * Represents an event triggered when a navigation ends successfully.\n *\n *\n */\nvar NavigationEnd = /** @class */ (function (_super) {\n __extends(NavigationEnd, _super);\n function NavigationEnd(\n /** @docsNotRequired */\n id, \n /** @docsNotRequired */\n url, \n /** @docsNotRequired */\n urlAfterRedirects) {\n var _this = _super.call(this, id, url) || this;\n _this.urlAfterRedirects = urlAfterRedirects;\n return _this;\n }\n /** @docsNotRequired */\n NavigationEnd.prototype.toString = function () {\n return \"NavigationEnd(id: \" + this.id + \", url: '\" + this.url + \"', urlAfterRedirects: '\" + this.urlAfterRedirects + \"')\";\n };\n return NavigationEnd;\n}(RouterEvent));\n/**\n * @description\n *\n * Represents an event triggered when a navigation is canceled.\n *\n *\n */\nvar NavigationCancel = /** @class */ (function (_super) {\n __extends(NavigationCancel, _super);\n function NavigationCancel(\n /** @docsNotRequired */\n id, \n /** @docsNotRequired */\n url, \n /** @docsNotRequired */\n reason) {\n var _this = _super.call(this, id, url) || this;\n _this.reason = reason;\n return _this;\n }\n /** @docsNotRequired */\n NavigationCancel.prototype.toString = function () { return \"NavigationCancel(id: \" + this.id + \", url: '\" + this.url + \"')\"; };\n return NavigationCancel;\n}(RouterEvent));\n/**\n * @description\n *\n * Represents an event triggered when a navigation fails due to an unexpected error.\n *\n *\n */\nvar NavigationError = /** @class */ (function (_super) {\n __extends(NavigationError, _super);\n function NavigationError(\n /** @docsNotRequired */\n id, \n /** @docsNotRequired */\n url, \n /** @docsNotRequired */\n error) {\n var _this = _super.call(this, id, url) || this;\n _this.error = error;\n return _this;\n }\n /** @docsNotRequired */\n NavigationError.prototype.toString = function () {\n return \"NavigationError(id: \" + this.id + \", url: '\" + this.url + \"', error: \" + this.error + \")\";\n };\n return NavigationError;\n}(RouterEvent));\n/**\n * @description\n *\n * Represents an event triggered when routes are recognized.\n *\n *\n */\nvar RoutesRecognized = /** @class */ (function (_super) {\n __extends(RoutesRecognized, _super);\n function RoutesRecognized(\n /** @docsNotRequired */\n id, \n /** @docsNotRequired */\n url, \n /** @docsNotRequired */\n urlAfterRedirects, \n /** @docsNotRequired */\n state) {\n var _this = _super.call(this, id, url) || this;\n _this.urlAfterRedirects = urlAfterRedirects;\n _this.state = state;\n return _this;\n }\n /** @docsNotRequired */\n RoutesRecognized.prototype.toString = function () {\n return \"RoutesRecognized(id: \" + this.id + \", url: '\" + this.url + \"', urlAfterRedirects: '\" + this.urlAfterRedirects + \"', state: \" + this.state + \")\";\n };\n return RoutesRecognized;\n}(RouterEvent));\n/**\n * @description\n *\n * Represents the start of the Guard phase of routing.\n *\n * @experimental\n */\nvar GuardsCheckStart = /** @class */ (function (_super) {\n __extends(GuardsCheckStart, _super);\n function GuardsCheckStart(\n /** @docsNotRequired */\n id, \n /** @docsNotRequired */\n url, \n /** @docsNotRequired */\n urlAfterRedirects, \n /** @docsNotRequired */\n state) {\n var _this = _super.call(this, id, url) || this;\n _this.urlAfterRedirects = urlAfterRedirects;\n _this.state = state;\n return _this;\n }\n GuardsCheckStart.prototype.toString = function () {\n return \"GuardsCheckStart(id: \" + this.id + \", url: '\" + this.url + \"', urlAfterRedirects: '\" + this.urlAfterRedirects + \"', state: \" + this.state + \")\";\n };\n return GuardsCheckStart;\n}(RouterEvent));\n/**\n * @description\n *\n * Represents the end of the Guard phase of routing.\n *\n * @experimental\n */\nvar GuardsCheckEnd = /** @class */ (function (_super) {\n __extends(GuardsCheckEnd, _super);\n function GuardsCheckEnd(\n /** @docsNotRequired */\n id, \n /** @docsNotRequired */\n url, \n /** @docsNotRequired */\n urlAfterRedirects, \n /** @docsNotRequired */\n state, \n /** @docsNotRequired */\n shouldActivate) {\n var _this = _super.call(this, id, url) || this;\n _this.urlAfterRedirects = urlAfterRedirects;\n _this.state = state;\n _this.shouldActivate = shouldActivate;\n return _this;\n }\n GuardsCheckEnd.prototype.toString = function () {\n return \"GuardsCheckEnd(id: \" + this.id + \", url: '\" + this.url + \"', urlAfterRedirects: '\" + this.urlAfterRedirects + \"', state: \" + this.state + \", shouldActivate: \" + this.shouldActivate + \")\";\n };\n return GuardsCheckEnd;\n}(RouterEvent));\n/**\n * @description\n *\n * Represents the start of the Resolve phase of routing. The timing of this\n * event may change, thus it's experimental. In the current iteration it will run\n * in the \"resolve\" phase whether there's things to resolve or not. In the future this\n * behavior may change to only run when there are things to be resolved.\n *\n * @experimental\n */\nvar ResolveStart = /** @class */ (function (_super) {\n __extends(ResolveStart, _super);\n function ResolveStart(\n /** @docsNotRequired */\n id, \n /** @docsNotRequired */\n url, \n /** @docsNotRequired */\n urlAfterRedirects, \n /** @docsNotRequired */\n state) {\n var _this = _super.call(this, id, url) || this;\n _this.urlAfterRedirects = urlAfterRedirects;\n _this.state = state;\n return _this;\n }\n ResolveStart.prototype.toString = function () {\n return \"ResolveStart(id: \" + this.id + \", url: '\" + this.url + \"', urlAfterRedirects: '\" + this.urlAfterRedirects + \"', state: \" + this.state + \")\";\n };\n return ResolveStart;\n}(RouterEvent));\n/**\n * @description\n *\n * Represents the end of the Resolve phase of routing. See note on\n * `ResolveStart` for use of this experimental API.\n *\n * @experimental\n */\nvar ResolveEnd = /** @class */ (function (_super) {\n __extends(ResolveEnd, _super);\n function ResolveEnd(\n /** @docsNotRequired */\n id, \n /** @docsNotRequired */\n url, \n /** @docsNotRequired */\n urlAfterRedirects, \n /** @docsNotRequired */\n state) {\n var _this = _super.call(this, id, url) || this;\n _this.urlAfterRedirects = urlAfterRedirects;\n _this.state = state;\n return _this;\n }\n ResolveEnd.prototype.toString = function () {\n return \"ResolveEnd(id: \" + this.id + \", url: '\" + this.url + \"', urlAfterRedirects: '\" + this.urlAfterRedirects + \"', state: \" + this.state + \")\";\n };\n return ResolveEnd;\n}(RouterEvent));\n/**\n * @description\n *\n * Represents an event triggered before lazy loading a route config.\n *\n * @experimental\n */\nvar RouteConfigLoadStart = /** @class */ (function () {\n function RouteConfigLoadStart(\n /** @docsNotRequired */\n route) {\n this.route = route;\n }\n RouteConfigLoadStart.prototype.toString = function () { return \"RouteConfigLoadStart(path: \" + this.route.path + \")\"; };\n return RouteConfigLoadStart;\n}());\n/**\n * @description\n *\n * Represents an event triggered when a route has been lazy loaded.\n *\n * @experimental\n */\nvar RouteConfigLoadEnd = /** @class */ (function () {\n function RouteConfigLoadEnd(\n /** @docsNotRequired */\n route) {\n this.route = route;\n }\n RouteConfigLoadEnd.prototype.toString = function () { return \"RouteConfigLoadEnd(path: \" + this.route.path + \")\"; };\n return RouteConfigLoadEnd;\n}());\n/**\n * @description\n *\n * Represents the start of end of the Resolve phase of routing. See note on\n * `ChildActivationEnd` for use of this experimental API.\n *\n * @experimental\n */\nvar ChildActivationStart = /** @class */ (function () {\n function ChildActivationStart(\n /** @docsNotRequired */\n snapshot) {\n this.snapshot = snapshot;\n }\n ChildActivationStart.prototype.toString = function () {\n var path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';\n return \"ChildActivationStart(path: '\" + path + \"')\";\n };\n return ChildActivationStart;\n}());\n/**\n * @description\n *\n * Represents the start of end of the Resolve phase of routing. See note on\n * `ChildActivationStart` for use of this experimental API.\n *\n * @experimental\n */\nvar ChildActivationEnd = /** @class */ (function () {\n function ChildActivationEnd(\n /** @docsNotRequired */\n snapshot) {\n this.snapshot = snapshot;\n }\n ChildActivationEnd.prototype.toString = function () {\n var path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';\n return \"ChildActivationEnd(path: '\" + path + \"')\";\n };\n return ChildActivationEnd;\n}());\n/**\n * @description\n *\n * Represents the start of end of the Resolve phase of routing. See note on\n * `ActivationEnd` for use of this experimental API.\n *\n * @experimental\n */\nvar ActivationStart = /** @class */ (function () {\n function ActivationStart(\n /** @docsNotRequired */\n snapshot) {\n this.snapshot = snapshot;\n }\n ActivationStart.prototype.toString = function () {\n var path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';\n return \"ActivationStart(path: '\" + path + \"')\";\n };\n return ActivationStart;\n}());\n/**\n * @description\n *\n * Represents the start of end of the Resolve phase of routing. See note on\n * `ActivationStart` for use of this experimental API.\n *\n * @experimental\n */\nvar ActivationEnd = /** @class */ (function () {\n function ActivationEnd(\n /** @docsNotRequired */\n snapshot) {\n this.snapshot = snapshot;\n }\n ActivationEnd.prototype.toString = function () {\n var path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';\n return \"ActivationEnd(path: '\" + path + \"')\";\n };\n return ActivationEnd;\n}());\n/**\n * @description\n *\n * Represents a scrolling event.\n */\nvar Scroll = /** @class */ (function () {\n function Scroll(\n /** @docsNotRequired */\n routerEvent, \n /** @docsNotRequired */\n position, \n /** @docsNotRequired */\n anchor) {\n this.routerEvent = routerEvent;\n this.position = position;\n this.anchor = anchor;\n }\n Scroll.prototype.toString = function () {\n var pos = this.position ? this.position[0] + \", \" + this.position[1] : null;\n return \"Scroll(anchor: '\" + this.anchor + \"', position: '\" + pos + \"')\";\n };\n return Scroll;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This component is used internally within the router to be a placeholder when an empty\n * router-outlet is needed. For example, with a config such as:\n *\n * `{path: 'parent', outlet: 'nav', children: [...]}`\n *\n * In order to render, there needs to be a component on this config, which will default\n * to this `EmptyOutletComponent`.\n */\nvar EmptyOutletComponent = /** @class */ (function () {\n function EmptyOutletComponent() {\n }\n EmptyOutletComponent.decorators = [\n { type: Component, args: [{ template: \"\" }] }\n ];\n return EmptyOutletComponent;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n *\n * Name of the primary outlet.\n *\n *\n */\nvar PRIMARY_OUTLET = 'primary';\nvar ParamsAsMap = /** @class */ (function () {\n function ParamsAsMap(params) {\n this.params = params || {};\n }\n ParamsAsMap.prototype.has = function (name) { return this.params.hasOwnProperty(name); };\n ParamsAsMap.prototype.get = function (name) {\n if (this.has(name)) {\n var v = this.params[name];\n return Array.isArray(v) ? v[0] : v;\n }\n return null;\n };\n ParamsAsMap.prototype.getAll = function (name) {\n if (this.has(name)) {\n var v = this.params[name];\n return Array.isArray(v) ? v : [v];\n }\n return [];\n };\n Object.defineProperty(ParamsAsMap.prototype, \"keys\", {\n get: function () { return Object.keys(this.params); },\n enumerable: true,\n configurable: true\n });\n return ParamsAsMap;\n}());\n/**\n * Convert a `Params` instance to a `ParamMap`.\n *\n *\n */\nfunction convertToParamMap(params) {\n return new ParamsAsMap(params);\n}\nvar NAVIGATION_CANCELING_ERROR = 'ngNavigationCancelingError';\nfunction navigationCancelingError(message) {\n var error = Error('NavigationCancelingError: ' + message);\n error[NAVIGATION_CANCELING_ERROR] = true;\n return error;\n}\nfunction isNavigationCancelingError(error) {\n return error && error[NAVIGATION_CANCELING_ERROR];\n}\n// Matches the route configuration (`route`) against the actual URL (`segments`).\nfunction defaultUrlMatcher(segments, segmentGroup, route) {\n var parts = route.path.split('/');\n if (parts.length > segments.length) {\n // The actual URL is shorter than the config, no match\n return null;\n }\n if (route.pathMatch === 'full' &&\n (segmentGroup.hasChildren() || parts.length < segments.length)) {\n // The config is longer than the actual URL but we are looking for a full match, return null\n return null;\n }\n var posParams = {};\n // Check each config part against the actual URL\n for (var index = 0; index < parts.length; index++) {\n var part = parts[index];\n var segment = segments[index];\n var isParameter = part.startsWith(':');\n if (isParameter) {\n posParams[part.substring(1)] = segment;\n }\n else if (part !== segment.path) {\n // The actual URL part does not match the config, no match\n return null;\n }\n }\n return { consumed: segments.slice(0, parts.length), posParams: posParams };\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar LoadedRouterConfig = /** @class */ (function () {\n function LoadedRouterConfig(routes, module) {\n this.routes = routes;\n this.module = module;\n }\n return LoadedRouterConfig;\n}());\nfunction validateConfig(config, parentPath) {\n if (parentPath === void 0) { parentPath = ''; }\n // forEach doesn't iterate undefined values\n for (var i = 0; i < config.length; i++) {\n var route = config[i];\n var fullPath = getFullPath(parentPath, route);\n validateNode(route, fullPath);\n }\n}\nfunction validateNode(route, fullPath) {\n if (!route) {\n throw new Error(\"\\n Invalid configuration of route '\" + fullPath + \"': Encountered undefined route.\\n The reason might be an extra comma.\\n\\n Example:\\n const routes: Routes = [\\n { path: '', redirectTo: '/dashboard', pathMatch: 'full' },\\n { path: 'dashboard', component: DashboardComponent },, << two commas\\n { path: 'detail/:id', component: HeroDetailComponent }\\n ];\\n \");\n }\n if (Array.isArray(route)) {\n throw new Error(\"Invalid configuration of route '\" + fullPath + \"': Array cannot be specified\");\n }\n if (!route.component && !route.children && !route.loadChildren &&\n (route.outlet && route.outlet !== PRIMARY_OUTLET)) {\n throw new Error(\"Invalid configuration of route '\" + fullPath + \"': a componentless route without children or loadChildren cannot have a named outlet set\");\n }\n if (route.redirectTo && route.children) {\n throw new Error(\"Invalid configuration of route '\" + fullPath + \"': redirectTo and children cannot be used together\");\n }\n if (route.redirectTo && route.loadChildren) {\n throw new Error(\"Invalid configuration of route '\" + fullPath + \"': redirectTo and loadChildren cannot be used together\");\n }\n if (route.children && route.loadChildren) {\n throw new Error(\"Invalid configuration of route '\" + fullPath + \"': children and loadChildren cannot be used together\");\n }\n if (route.redirectTo && route.component) {\n throw new Error(\"Invalid configuration of route '\" + fullPath + \"': redirectTo and component cannot be used together\");\n }\n if (route.path && route.matcher) {\n throw new Error(\"Invalid configuration of route '\" + fullPath + \"': path and matcher cannot be used together\");\n }\n if (route.redirectTo === void 0 && !route.component && !route.children && !route.loadChildren) {\n throw new Error(\"Invalid configuration of route '\" + fullPath + \"'. One of the following must be provided: component, redirectTo, children or loadChildren\");\n }\n if (route.path === void 0 && route.matcher === void 0) {\n throw new Error(\"Invalid configuration of route '\" + fullPath + \"': routes must have either a path or a matcher specified\");\n }\n if (typeof route.path === 'string' && route.path.charAt(0) === '/') {\n throw new Error(\"Invalid configuration of route '\" + fullPath + \"': path cannot start with a slash\");\n }\n if (route.path === '' && route.redirectTo !== void 0 && route.pathMatch === void 0) {\n var exp = \"The default value of 'pathMatch' is 'prefix', but often the intent is to use 'full'.\";\n throw new Error(\"Invalid configuration of route '{path: \\\"\" + fullPath + \"\\\", redirectTo: \\\"\" + route.redirectTo + \"\\\"}': please provide 'pathMatch'. \" + exp);\n }\n if (route.pathMatch !== void 0 && route.pathMatch !== 'full' && route.pathMatch !== 'prefix') {\n throw new Error(\"Invalid configuration of route '\" + fullPath + \"': pathMatch can only be set to 'prefix' or 'full'\");\n }\n if (route.children) {\n validateConfig(route.children, fullPath);\n }\n}\nfunction getFullPath(parentPath, currentRoute) {\n if (!currentRoute) {\n return parentPath;\n }\n if (!parentPath && !currentRoute.path) {\n return '';\n }\n else if (parentPath && !currentRoute.path) {\n return parentPath + \"/\";\n }\n else if (!parentPath && currentRoute.path) {\n return currentRoute.path;\n }\n else {\n return parentPath + \"/\" + currentRoute.path;\n }\n}\n/**\n * Makes a copy of the config and adds any default required properties.\n */\nfunction standardizeConfig(r) {\n var children = r.children && r.children.map(standardizeConfig);\n var c = children ? __assign({}, r, { children: children }) : __assign({}, r);\n if (!c.component && (children || c.loadChildren) && (c.outlet && c.outlet !== PRIMARY_OUTLET)) {\n c.component = EmptyOutletComponent;\n }\n return c;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction shallowEqualArrays(a, b) {\n if (a.length !== b.length)\n return false;\n for (var i = 0; i < a.length; ++i) {\n if (!shallowEqual(a[i], b[i]))\n return false;\n }\n return true;\n}\nfunction shallowEqual(a, b) {\n var k1 = Object.keys(a);\n var k2 = Object.keys(b);\n if (k1.length != k2.length) {\n return false;\n }\n var key;\n for (var i = 0; i < k1.length; i++) {\n key = k1[i];\n if (a[key] !== b[key]) {\n return false;\n }\n }\n return true;\n}\n/**\n * Flattens single-level nested arrays.\n */\nfunction flatten(arr) {\n return Array.prototype.concat.apply([], arr);\n}\n/**\n * Return the last element of an array.\n */\nfunction last$1(a) {\n return a.length > 0 ? a[a.length - 1] : null;\n}\nfunction forEach(map$$1, callback) {\n for (var prop in map$$1) {\n if (map$$1.hasOwnProperty(prop)) {\n callback(map$$1[prop], prop);\n }\n }\n}\nfunction waitForMap(obj, fn) {\n if (Object.keys(obj).length === 0) {\n return of({});\n }\n var waitHead = [];\n var waitTail = [];\n var res = {};\n forEach(obj, function (a, k) {\n var mapped = fn(k, a).pipe(map(function (r) { return res[k] = r; }));\n if (k === PRIMARY_OUTLET) {\n waitHead.push(mapped);\n }\n else {\n waitTail.push(mapped);\n }\n });\n // Closure compiler has problem with using spread operator here. So just using Array.concat.\n return of.apply(null, waitHead.concat(waitTail)).pipe(concatAll(), last(), map(function () { return res; }));\n}\n/**\n * ANDs Observables by merging all input observables, reducing to an Observable verifying all\n * input Observables return `true`.\n */\nfunction andObservables(observables) {\n return observables.pipe(mergeAll(), every(function (result) { return result === true; }));\n}\nfunction wrapIntoObservable(value) {\n if (ɵisObservable(value)) {\n return value;\n }\n if (ɵisPromise(value)) {\n // Use `Promise.resolve()` to wrap promise-like instances.\n // Required ie when a Resolver returns a AngularJS `$q` promise to correctly trigger the\n // change detection.\n return from(Promise.resolve(value));\n }\n return of(value);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction createEmptyUrlTree() {\n return new UrlTree(new UrlSegmentGroup([], {}), {}, null);\n}\nfunction containsTree(container, containee, exact) {\n if (exact) {\n return equalQueryParams(container.queryParams, containee.queryParams) &&\n equalSegmentGroups(container.root, containee.root);\n }\n return containsQueryParams(container.queryParams, containee.queryParams) &&\n containsSegmentGroup(container.root, containee.root);\n}\nfunction equalQueryParams(container, containee) {\n // TODO: This does not handle array params correctly.\n return shallowEqual(container, containee);\n}\nfunction equalSegmentGroups(container, containee) {\n if (!equalPath(container.segments, containee.segments))\n return false;\n if (container.numberOfChildren !== containee.numberOfChildren)\n return false;\n for (var c in containee.children) {\n if (!container.children[c])\n return false;\n if (!equalSegmentGroups(container.children[c], containee.children[c]))\n return false;\n }\n return true;\n}\nfunction containsQueryParams(container, containee) {\n // TODO: This does not handle array params correctly.\n return Object.keys(containee).length <= Object.keys(container).length &&\n Object.keys(containee).every(function (key) { return containee[key] === container[key]; });\n}\nfunction containsSegmentGroup(container, containee) {\n return containsSegmentGroupHelper(container, containee, containee.segments);\n}\nfunction containsSegmentGroupHelper(container, containee, containeePaths) {\n if (container.segments.length > containeePaths.length) {\n var current = container.segments.slice(0, containeePaths.length);\n if (!equalPath(current, containeePaths))\n return false;\n if (containee.hasChildren())\n return false;\n return true;\n }\n else if (container.segments.length === containeePaths.length) {\n if (!equalPath(container.segments, containeePaths))\n return false;\n for (var c in containee.children) {\n if (!container.children[c])\n return false;\n if (!containsSegmentGroup(container.children[c], containee.children[c]))\n return false;\n }\n return true;\n }\n else {\n var current = containeePaths.slice(0, container.segments.length);\n var next = containeePaths.slice(container.segments.length);\n if (!equalPath(container.segments, current))\n return false;\n if (!container.children[PRIMARY_OUTLET])\n return false;\n return containsSegmentGroupHelper(container.children[PRIMARY_OUTLET], containee, next);\n }\n}\n/**\n * @description\n *\n * Represents the parsed URL.\n *\n * Since a router state is a tree, and the URL is nothing but a serialized state, the URL is a\n * serialized tree.\n * UrlTree is a data structure that provides a lot of affordances in dealing with URLs\n *\n * ### Example\n *\n * ```\n * @Component({templateUrl:'template.html'})\n * class MyComponent {\n * constructor(router: Router) {\n * const tree: UrlTree =\n * router.parseUrl('/team/33/(user/victor//support:help)?debug=true#fragment');\n * const f = tree.fragment; // return 'fragment'\n * const q = tree.queryParams; // returns {debug: 'true'}\n * const g: UrlSegmentGroup = tree.root.children[PRIMARY_OUTLET];\n * const s: UrlSegment[] = g.segments; // returns 2 segments 'team' and '33'\n * g.children[PRIMARY_OUTLET].segments; // returns 2 segments 'user' and 'victor'\n * g.children['support'].segments; // return 1 segment 'help'\n * }\n * }\n * ```\n *\n *\n */\nvar UrlTree = /** @class */ (function () {\n /** @internal */\n function UrlTree(\n /** The root segment group of the URL tree */\n root, \n /** The query params of the URL */\n queryParams, \n /** The fragment of the URL */\n fragment) {\n this.root = root;\n this.queryParams = queryParams;\n this.fragment = fragment;\n }\n Object.defineProperty(UrlTree.prototype, \"queryParamMap\", {\n get: function () {\n if (!this._queryParamMap) {\n this._queryParamMap = convertToParamMap(this.queryParams);\n }\n return this._queryParamMap;\n },\n enumerable: true,\n configurable: true\n });\n /** @docsNotRequired */\n UrlTree.prototype.toString = function () { return DEFAULT_SERIALIZER.serialize(this); };\n return UrlTree;\n}());\n/**\n * @description\n *\n * Represents the parsed URL segment group.\n *\n * See `UrlTree` for more information.\n *\n *\n */\nvar UrlSegmentGroup = /** @class */ (function () {\n function UrlSegmentGroup(\n /** The URL segments of this group. See `UrlSegment` for more information */\n segments, \n /** The list of children of this group */\n children) {\n var _this = this;\n this.segments = segments;\n this.children = children;\n /** The parent node in the url tree */\n this.parent = null;\n forEach(children, function (v, k) { return v.parent = _this; });\n }\n /** Whether the segment has child segments */\n UrlSegmentGroup.prototype.hasChildren = function () { return this.numberOfChildren > 0; };\n Object.defineProperty(UrlSegmentGroup.prototype, \"numberOfChildren\", {\n /** Number of child segments */\n get: function () { return Object.keys(this.children).length; },\n enumerable: true,\n configurable: true\n });\n /** @docsNotRequired */\n UrlSegmentGroup.prototype.toString = function () { return serializePaths(this); };\n return UrlSegmentGroup;\n}());\n/**\n * @description\n *\n * Represents a single URL segment.\n *\n * A UrlSegment is a part of a URL between the two slashes. It contains a path and the matrix\n * parameters associated with the segment.\n *\n * ## Example\n *\n * ```\n * @Component({templateUrl:'template.html'})\n * class MyComponent {\n * constructor(router: Router) {\n * const tree: UrlTree = router.parseUrl('/team;id=33');\n * const g: UrlSegmentGroup = tree.root.children[PRIMARY_OUTLET];\n * const s: UrlSegment[] = g.segments;\n * s[0].path; // returns 'team'\n * s[0].parameters; // returns {id: 33}\n * }\n * }\n * ```\n *\n *\n */\nvar UrlSegment = /** @class */ (function () {\n function UrlSegment(\n /** The path part of a URL segment */\n path, \n /** The matrix parameters associated with a segment */\n parameters) {\n this.path = path;\n this.parameters = parameters;\n }\n Object.defineProperty(UrlSegment.prototype, \"parameterMap\", {\n get: function () {\n if (!this._parameterMap) {\n this._parameterMap = convertToParamMap(this.parameters);\n }\n return this._parameterMap;\n },\n enumerable: true,\n configurable: true\n });\n /** @docsNotRequired */\n UrlSegment.prototype.toString = function () { return serializePath(this); };\n return UrlSegment;\n}());\nfunction equalSegments(as, bs) {\n return equalPath(as, bs) && as.every(function (a, i) { return shallowEqual(a.parameters, bs[i].parameters); });\n}\nfunction equalPath(as, bs) {\n if (as.length !== bs.length)\n return false;\n return as.every(function (a, i) { return a.path === bs[i].path; });\n}\nfunction mapChildrenIntoArray(segment, fn) {\n var res = [];\n forEach(segment.children, function (child, childOutlet) {\n if (childOutlet === PRIMARY_OUTLET) {\n res = res.concat(fn(child, childOutlet));\n }\n });\n forEach(segment.children, function (child, childOutlet) {\n if (childOutlet !== PRIMARY_OUTLET) {\n res = res.concat(fn(child, childOutlet));\n }\n });\n return res;\n}\n/**\n * @description\n *\n * Serializes and deserializes a URL string into a URL tree.\n *\n * The url serialization strategy is customizable. You can\n * make all URLs case insensitive by providing a custom UrlSerializer.\n *\n * See `DefaultUrlSerializer` for an example of a URL serializer.\n *\n *\n */\nvar UrlSerializer = /** @class */ (function () {\n function UrlSerializer() {\n }\n return UrlSerializer;\n}());\n/**\n * @description\n *\n * A default implementation of the `UrlSerializer`.\n *\n * Example URLs:\n *\n * ```\n * /inbox/33(popup:compose)\n * /inbox/33;open=true/messages/44\n * ```\n *\n * DefaultUrlSerializer uses parentheses to serialize secondary segments (e.g., popup:compose), the\n * colon syntax to specify the outlet, and the ';parameter=value' syntax (e.g., open=true) to\n * specify route specific parameters.\n *\n *\n */\nvar DefaultUrlSerializer = /** @class */ (function () {\n function DefaultUrlSerializer() {\n }\n /** Parses a url into a `UrlTree` */\n DefaultUrlSerializer.prototype.parse = function (url) {\n var p = new UrlParser(url);\n return new UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment());\n };\n /** Converts a `UrlTree` into a url */\n DefaultUrlSerializer.prototype.serialize = function (tree) {\n var segment = \"/\" + serializeSegment(tree.root, true);\n var query = serializeQueryParams(tree.queryParams);\n var fragment = typeof tree.fragment === \"string\" ? \"#\" + encodeUriFragment(tree.fragment) : '';\n return \"\" + segment + query + fragment;\n };\n return DefaultUrlSerializer;\n}());\nvar DEFAULT_SERIALIZER = new DefaultUrlSerializer();\nfunction serializePaths(segment) {\n return segment.segments.map(function (p) { return serializePath(p); }).join('/');\n}\nfunction serializeSegment(segment, root) {\n if (!segment.hasChildren()) {\n return serializePaths(segment);\n }\n if (root) {\n var primary = segment.children[PRIMARY_OUTLET] ?\n serializeSegment(segment.children[PRIMARY_OUTLET], false) :\n '';\n var children_1 = [];\n forEach(segment.children, function (v, k) {\n if (k !== PRIMARY_OUTLET) {\n children_1.push(k + \":\" + serializeSegment(v, false));\n }\n });\n return children_1.length > 0 ? primary + \"(\" + children_1.join('//') + \")\" : primary;\n }\n else {\n var children = mapChildrenIntoArray(segment, function (v, k) {\n if (k === PRIMARY_OUTLET) {\n return [serializeSegment(segment.children[PRIMARY_OUTLET], false)];\n }\n return [k + \":\" + serializeSegment(v, false)];\n });\n return serializePaths(segment) + \"/(\" + children.join('//') + \")\";\n }\n}\n/**\n * Encodes a URI string with the default encoding. This function will only ever be called from\n * `encodeUriQuery` or `encodeUriSegment` as it's the base set of encodings to be used. We need\n * a custom encoding because encodeURIComponent is too aggressive and encodes stuff that doesn't\n * have to be encoded per https://url.spec.whatwg.org.\n */\nfunction encodeUriString(s) {\n return encodeURIComponent(s)\n .replace(/%40/g, '@')\n .replace(/%3A/gi, ':')\n .replace(/%24/g, '$')\n .replace(/%2C/gi, ',');\n}\n/**\n * This function should be used to encode both keys and values in a query string key/value. In\n * the following URL, you need to call encodeUriQuery on \"k\" and \"v\":\n *\n * http://www.site.org/html;mk=mv?k=v#f\n */\nfunction encodeUriQuery(s) {\n return encodeUriString(s).replace(/%3B/gi, ';');\n}\n/**\n * This function should be used to encode a URL fragment. In the following URL, you need to call\n * encodeUriFragment on \"f\":\n *\n * http://www.site.org/html;mk=mv?k=v#f\n */\nfunction encodeUriFragment(s) {\n return encodeURI(s);\n}\n/**\n * This function should be run on any URI segment as well as the key and value in a key/value\n * pair for matrix params. In the following URL, you need to call encodeUriSegment on \"html\",\n * \"mk\", and \"mv\":\n *\n * http://www.site.org/html;mk=mv?k=v#f\n */\nfunction encodeUriSegment(s) {\n return encodeUriString(s).replace(/\\(/g, '%28').replace(/\\)/g, '%29').replace(/%26/gi, '&');\n}\nfunction decode(s) {\n return decodeURIComponent(s);\n}\n// Query keys/values should have the \"+\" replaced first, as \"+\" in a query string is \" \".\n// decodeURIComponent function will not decode \"+\" as a space.\nfunction decodeQuery(s) {\n return decode(s.replace(/\\+/g, '%20'));\n}\nfunction serializePath(path) {\n return \"\" + encodeUriSegment(path.path) + serializeMatrixParams(path.parameters);\n}\nfunction serializeMatrixParams(params) {\n return Object.keys(params)\n .map(function (key) { return \";\" + encodeUriSegment(key) + \"=\" + encodeUriSegment(params[key]); })\n .join('');\n}\nfunction serializeQueryParams(params) {\n var strParams = Object.keys(params).map(function (name) {\n var value = params[name];\n return Array.isArray(value) ?\n value.map(function (v) { return encodeUriQuery(name) + \"=\" + encodeUriQuery(v); }).join('&') :\n encodeUriQuery(name) + \"=\" + encodeUriQuery(value);\n });\n return strParams.length ? \"?\" + strParams.join(\"&\") : '';\n}\nvar SEGMENT_RE = /^[^\\/()?;=#]+/;\nfunction matchSegments(str) {\n var match = str.match(SEGMENT_RE);\n return match ? match[0] : '';\n}\nvar QUERY_PARAM_RE = /^[^=?&#]+/;\n// Return the name of the query param at the start of the string or an empty string\nfunction matchQueryParams(str) {\n var match = str.match(QUERY_PARAM_RE);\n return match ? match[0] : '';\n}\nvar QUERY_PARAM_VALUE_RE = /^[^?&#]+/;\n// Return the value of the query param at the start of the string or an empty string\nfunction matchUrlQueryParamValue(str) {\n var match = str.match(QUERY_PARAM_VALUE_RE);\n return match ? match[0] : '';\n}\nvar UrlParser = /** @class */ (function () {\n function UrlParser(url) {\n this.url = url;\n this.remaining = url;\n }\n UrlParser.prototype.parseRootSegment = function () {\n this.consumeOptional('/');\n if (this.remaining === '' || this.peekStartsWith('?') || this.peekStartsWith('#')) {\n return new UrlSegmentGroup([], {});\n }\n // The root segment group never has segments\n return new UrlSegmentGroup([], this.parseChildren());\n };\n UrlParser.prototype.parseQueryParams = function () {\n var params = {};\n if (this.consumeOptional('?')) {\n do {\n this.parseQueryParam(params);\n } while (this.consumeOptional('&'));\n }\n return params;\n };\n UrlParser.prototype.parseFragment = function () {\n return this.consumeOptional('#') ? decodeURIComponent(this.remaining) : null;\n };\n UrlParser.prototype.parseChildren = function () {\n if (this.remaining === '') {\n return {};\n }\n this.consumeOptional('/');\n var segments = [];\n if (!this.peekStartsWith('(')) {\n segments.push(this.parseSegment());\n }\n while (this.peekStartsWith('/') && !this.peekStartsWith('//') && !this.peekStartsWith('/(')) {\n this.capture('/');\n segments.push(this.parseSegment());\n }\n var children = {};\n if (this.peekStartsWith('/(')) {\n this.capture('/');\n children = this.parseParens(true);\n }\n var res = {};\n if (this.peekStartsWith('(')) {\n res = this.parseParens(false);\n }\n if (segments.length > 0 || Object.keys(children).length > 0) {\n res[PRIMARY_OUTLET] = new UrlSegmentGroup(segments, children);\n }\n return res;\n };\n // parse a segment with its matrix parameters\n // ie `name;k1=v1;k2`\n UrlParser.prototype.parseSegment = function () {\n var path = matchSegments(this.remaining);\n if (path === '' && this.peekStartsWith(';')) {\n throw new Error(\"Empty path url segment cannot have parameters: '\" + this.remaining + \"'.\");\n }\n this.capture(path);\n return new UrlSegment(decode(path), this.parseMatrixParams());\n };\n UrlParser.prototype.parseMatrixParams = function () {\n var params = {};\n while (this.consumeOptional(';')) {\n this.parseParam(params);\n }\n return params;\n };\n UrlParser.prototype.parseParam = function (params) {\n var key = matchSegments(this.remaining);\n if (!key) {\n return;\n }\n this.capture(key);\n var value = '';\n if (this.consumeOptional('=')) {\n var valueMatch = matchSegments(this.remaining);\n if (valueMatch) {\n value = valueMatch;\n this.capture(value);\n }\n }\n params[decode(key)] = decode(value);\n };\n // Parse a single query parameter `name[=value]`\n UrlParser.prototype.parseQueryParam = function (params) {\n var key = matchQueryParams(this.remaining);\n if (!key) {\n return;\n }\n this.capture(key);\n var value = '';\n if (this.consumeOptional('=')) {\n var valueMatch = matchUrlQueryParamValue(this.remaining);\n if (valueMatch) {\n value = valueMatch;\n this.capture(value);\n }\n }\n var decodedKey = decodeQuery(key);\n var decodedVal = decodeQuery(value);\n if (params.hasOwnProperty(decodedKey)) {\n // Append to existing values\n var currentVal = params[decodedKey];\n if (!Array.isArray(currentVal)) {\n currentVal = [currentVal];\n params[decodedKey] = currentVal;\n }\n currentVal.push(decodedVal);\n }\n else {\n // Create a new value\n params[decodedKey] = decodedVal;\n }\n };\n // parse `(a/b//outlet_name:c/d)`\n UrlParser.prototype.parseParens = function (allowPrimary) {\n var segments = {};\n this.capture('(');\n while (!this.consumeOptional(')') && this.remaining.length > 0) {\n var path = matchSegments(this.remaining);\n var next = this.remaining[path.length];\n // if is is not one of these characters, then the segment was unescaped\n // or the group was not closed\n if (next !== '/' && next !== ')' && next !== ';') {\n throw new Error(\"Cannot parse url '\" + this.url + \"'\");\n }\n var outletName = undefined;\n if (path.indexOf(':') > -1) {\n outletName = path.substr(0, path.indexOf(':'));\n this.capture(outletName);\n this.capture(':');\n }\n else if (allowPrimary) {\n outletName = PRIMARY_OUTLET;\n }\n var children = this.parseChildren();\n segments[outletName] = Object.keys(children).length === 1 ? children[PRIMARY_OUTLET] :\n new UrlSegmentGroup([], children);\n this.consumeOptional('//');\n }\n return segments;\n };\n UrlParser.prototype.peekStartsWith = function (str) { return this.remaining.startsWith(str); };\n // Consumes the prefix when it is present and returns whether it has been consumed\n UrlParser.prototype.consumeOptional = function (str) {\n if (this.peekStartsWith(str)) {\n this.remaining = this.remaining.substring(str.length);\n return true;\n }\n return false;\n };\n UrlParser.prototype.capture = function (str) {\n if (!this.consumeOptional(str)) {\n throw new Error(\"Expected \\\"\" + str + \"\\\".\");\n }\n };\n return UrlParser;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar NoMatch = /** @class */ (function () {\n function NoMatch(segmentGroup) {\n this.segmentGroup = segmentGroup || null;\n }\n return NoMatch;\n}());\nvar AbsoluteRedirect = /** @class */ (function () {\n function AbsoluteRedirect(urlTree) {\n this.urlTree = urlTree;\n }\n return AbsoluteRedirect;\n}());\nfunction noMatch(segmentGroup) {\n return new Observable(function (obs) { return obs.error(new NoMatch(segmentGroup)); });\n}\nfunction absoluteRedirect(newTree) {\n return new Observable(function (obs) { return obs.error(new AbsoluteRedirect(newTree)); });\n}\nfunction namedOutletsRedirect(redirectTo) {\n return new Observable(function (obs) { return obs.error(new Error(\"Only absolute redirects can have named outlets. redirectTo: '\" + redirectTo + \"'\")); });\n}\nfunction canLoadFails(route) {\n return new Observable(function (obs) { return obs.error(navigationCancelingError(\"Cannot load children because the guard of the route \\\"path: '\" + route.path + \"'\\\" returned false\")); });\n}\n/**\n * Returns the `UrlTree` with the redirection applied.\n *\n * Lazy modules are loaded along the way.\n */\nfunction applyRedirects(moduleInjector, configLoader, urlSerializer, urlTree, config) {\n return new ApplyRedirects(moduleInjector, configLoader, urlSerializer, urlTree, config).apply();\n}\nvar ApplyRedirects = /** @class */ (function () {\n function ApplyRedirects(moduleInjector, configLoader, urlSerializer, urlTree, config) {\n this.configLoader = configLoader;\n this.urlSerializer = urlSerializer;\n this.urlTree = urlTree;\n this.config = config;\n this.allowRedirects = true;\n this.ngModule = moduleInjector.get(NgModuleRef);\n }\n ApplyRedirects.prototype.apply = function () {\n var _this = this;\n var expanded$ = this.expandSegmentGroup(this.ngModule, this.config, this.urlTree.root, PRIMARY_OUTLET);\n var urlTrees$ = expanded$.pipe(map(function (rootSegmentGroup) { return _this.createUrlTree(rootSegmentGroup, _this.urlTree.queryParams, _this.urlTree.fragment); }));\n return urlTrees$.pipe(catchError(function (e) {\n if (e instanceof AbsoluteRedirect) {\n // after an absolute redirect we do not apply any more redirects!\n _this.allowRedirects = false;\n // we need to run matching, so we can fetch all lazy-loaded modules\n return _this.match(e.urlTree);\n }\n if (e instanceof NoMatch) {\n throw _this.noMatchError(e);\n }\n throw e;\n }));\n };\n ApplyRedirects.prototype.match = function (tree) {\n var _this = this;\n var expanded$ = this.expandSegmentGroup(this.ngModule, this.config, tree.root, PRIMARY_OUTLET);\n var mapped$ = expanded$.pipe(map(function (rootSegmentGroup) {\n return _this.createUrlTree(rootSegmentGroup, tree.queryParams, tree.fragment);\n }));\n return mapped$.pipe(catchError(function (e) {\n if (e instanceof NoMatch) {\n throw _this.noMatchError(e);\n }\n throw e;\n }));\n };\n ApplyRedirects.prototype.noMatchError = function (e) {\n return new Error(\"Cannot match any routes. URL Segment: '\" + e.segmentGroup + \"'\");\n };\n ApplyRedirects.prototype.createUrlTree = function (rootCandidate, queryParams, fragment) {\n var _a;\n var root = rootCandidate.segments.length > 0 ?\n new UrlSegmentGroup([], (_a = {}, _a[PRIMARY_OUTLET] = rootCandidate, _a)) :\n rootCandidate;\n return new UrlTree(root, queryParams, fragment);\n };\n ApplyRedirects.prototype.expandSegmentGroup = function (ngModule, routes, segmentGroup, outlet) {\n if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {\n return this.expandChildren(ngModule, routes, segmentGroup)\n .pipe(map(function (children) { return new UrlSegmentGroup([], children); }));\n }\n return this.expandSegment(ngModule, segmentGroup, routes, segmentGroup.segments, outlet, true);\n };\n // Recursively expand segment groups for all the child outlets\n ApplyRedirects.prototype.expandChildren = function (ngModule, routes, segmentGroup) {\n var _this = this;\n return waitForMap(segmentGroup.children, function (childOutlet, child) { return _this.expandSegmentGroup(ngModule, routes, child, childOutlet); });\n };\n ApplyRedirects.prototype.expandSegment = function (ngModule, segmentGroup, routes, segments, outlet, allowRedirects) {\n var _this = this;\n return of.apply(void 0, __spread(routes)).pipe(map(function (r) {\n var expanded$ = _this.expandSegmentAgainstRoute(ngModule, segmentGroup, routes, r, segments, outlet, allowRedirects);\n return expanded$.pipe(catchError(function (e) {\n if (e instanceof NoMatch) {\n // TODO(i): this return type doesn't match the declared Observable -\n // talk to Jason\n return of(null);\n }\n throw e;\n }));\n }), concatAll(), first(function (s) { return !!s; }), catchError(function (e, _) {\n if (e instanceof EmptyError || e.name === 'EmptyError') {\n if (_this.noLeftoversInUrl(segmentGroup, segments, outlet)) {\n return of(new UrlSegmentGroup([], {}));\n }\n throw new NoMatch(segmentGroup);\n }\n throw e;\n }));\n };\n ApplyRedirects.prototype.noLeftoversInUrl = function (segmentGroup, segments, outlet) {\n return segments.length === 0 && !segmentGroup.children[outlet];\n };\n ApplyRedirects.prototype.expandSegmentAgainstRoute = function (ngModule, segmentGroup, routes, route, paths, outlet, allowRedirects) {\n if (getOutlet(route) !== outlet) {\n return noMatch(segmentGroup);\n }\n if (route.redirectTo === undefined) {\n return this.matchSegmentAgainstRoute(ngModule, segmentGroup, route, paths);\n }\n if (allowRedirects && this.allowRedirects) {\n return this.expandSegmentAgainstRouteUsingRedirect(ngModule, segmentGroup, routes, route, paths, outlet);\n }\n return noMatch(segmentGroup);\n };\n ApplyRedirects.prototype.expandSegmentAgainstRouteUsingRedirect = function (ngModule, segmentGroup, routes, route, segments, outlet) {\n if (route.path === '**') {\n return this.expandWildCardWithParamsAgainstRouteUsingRedirect(ngModule, routes, route, outlet);\n }\n return this.expandRegularSegmentAgainstRouteUsingRedirect(ngModule, segmentGroup, routes, route, segments, outlet);\n };\n ApplyRedirects.prototype.expandWildCardWithParamsAgainstRouteUsingRedirect = function (ngModule, routes, route, outlet) {\n var _this = this;\n var newTree = this.applyRedirectCommands([], route.redirectTo, {});\n if (route.redirectTo.startsWith('/')) {\n return absoluteRedirect(newTree);\n }\n return this.lineralizeSegments(route, newTree).pipe(mergeMap(function (newSegments) {\n var group = new UrlSegmentGroup(newSegments, {});\n return _this.expandSegment(ngModule, group, routes, newSegments, outlet, false);\n }));\n };\n ApplyRedirects.prototype.expandRegularSegmentAgainstRouteUsingRedirect = function (ngModule, segmentGroup, routes, route, segments, outlet) {\n var _this = this;\n var _a = match(segmentGroup, route, segments), matched = _a.matched, consumedSegments = _a.consumedSegments, lastChild = _a.lastChild, positionalParamSegments = _a.positionalParamSegments;\n if (!matched)\n return noMatch(segmentGroup);\n var newTree = this.applyRedirectCommands(consumedSegments, route.redirectTo, positionalParamSegments);\n if (route.redirectTo.startsWith('/')) {\n return absoluteRedirect(newTree);\n }\n return this.lineralizeSegments(route, newTree).pipe(mergeMap(function (newSegments) {\n return _this.expandSegment(ngModule, segmentGroup, routes, newSegments.concat(segments.slice(lastChild)), outlet, false);\n }));\n };\n ApplyRedirects.prototype.matchSegmentAgainstRoute = function (ngModule, rawSegmentGroup, route, segments) {\n var _this = this;\n if (route.path === '**') {\n if (route.loadChildren) {\n return this.configLoader.load(ngModule.injector, route)\n .pipe(map(function (cfg) {\n route._loadedConfig = cfg;\n return new UrlSegmentGroup(segments, {});\n }));\n }\n return of(new UrlSegmentGroup(segments, {}));\n }\n var _a = match(rawSegmentGroup, route, segments), matched = _a.matched, consumedSegments = _a.consumedSegments, lastChild = _a.lastChild;\n if (!matched)\n return noMatch(rawSegmentGroup);\n var rawSlicedSegments = segments.slice(lastChild);\n var childConfig$ = this.getChildConfig(ngModule, route);\n return childConfig$.pipe(mergeMap(function (routerConfig) {\n var childModule = routerConfig.module;\n var childConfig = routerConfig.routes;\n var _a = split(rawSegmentGroup, consumedSegments, rawSlicedSegments, childConfig), segmentGroup = _a.segmentGroup, slicedSegments = _a.slicedSegments;\n if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {\n var expanded$_1 = _this.expandChildren(childModule, childConfig, segmentGroup);\n return expanded$_1.pipe(map(function (children) { return new UrlSegmentGroup(consumedSegments, children); }));\n }\n if (childConfig.length === 0 && slicedSegments.length === 0) {\n return of(new UrlSegmentGroup(consumedSegments, {}));\n }\n var expanded$ = _this.expandSegment(childModule, segmentGroup, childConfig, slicedSegments, PRIMARY_OUTLET, true);\n return expanded$.pipe(map(function (cs) {\n return new UrlSegmentGroup(consumedSegments.concat(cs.segments), cs.children);\n }));\n }));\n };\n ApplyRedirects.prototype.getChildConfig = function (ngModule, route) {\n var _this = this;\n if (route.children) {\n // The children belong to the same module\n return of(new LoadedRouterConfig(route.children, ngModule));\n }\n if (route.loadChildren) {\n // lazy children belong to the loaded module\n if (route._loadedConfig !== undefined) {\n return of(route._loadedConfig);\n }\n return runCanLoadGuard(ngModule.injector, route).pipe(mergeMap(function (shouldLoad) {\n if (shouldLoad) {\n return _this.configLoader.load(ngModule.injector, route)\n .pipe(map(function (cfg) {\n route._loadedConfig = cfg;\n return cfg;\n }));\n }\n return canLoadFails(route);\n }));\n }\n return of(new LoadedRouterConfig([], ngModule));\n };\n ApplyRedirects.prototype.lineralizeSegments = function (route, urlTree) {\n var res = [];\n var c = urlTree.root;\n while (true) {\n res = res.concat(c.segments);\n if (c.numberOfChildren === 0) {\n return of(res);\n }\n if (c.numberOfChildren > 1 || !c.children[PRIMARY_OUTLET]) {\n return namedOutletsRedirect(route.redirectTo);\n }\n c = c.children[PRIMARY_OUTLET];\n }\n };\n ApplyRedirects.prototype.applyRedirectCommands = function (segments, redirectTo, posParams) {\n return this.applyRedirectCreatreUrlTree(redirectTo, this.urlSerializer.parse(redirectTo), segments, posParams);\n };\n ApplyRedirects.prototype.applyRedirectCreatreUrlTree = function (redirectTo, urlTree, segments, posParams) {\n var newRoot = this.createSegmentGroup(redirectTo, urlTree.root, segments, posParams);\n return new UrlTree(newRoot, this.createQueryParams(urlTree.queryParams, this.urlTree.queryParams), urlTree.fragment);\n };\n ApplyRedirects.prototype.createQueryParams = function (redirectToParams, actualParams) {\n var res = {};\n forEach(redirectToParams, function (v, k) {\n var copySourceValue = typeof v === 'string' && v.startsWith(':');\n if (copySourceValue) {\n var sourceName = v.substring(1);\n res[k] = actualParams[sourceName];\n }\n else {\n res[k] = v;\n }\n });\n return res;\n };\n ApplyRedirects.prototype.createSegmentGroup = function (redirectTo, group, segments, posParams) {\n var _this = this;\n var updatedSegments = this.createSegments(redirectTo, group.segments, segments, posParams);\n var children = {};\n forEach(group.children, function (child, name) {\n children[name] = _this.createSegmentGroup(redirectTo, child, segments, posParams);\n });\n return new UrlSegmentGroup(updatedSegments, children);\n };\n ApplyRedirects.prototype.createSegments = function (redirectTo, redirectToSegments, actualSegments, posParams) {\n var _this = this;\n return redirectToSegments.map(function (s) { return s.path.startsWith(':') ? _this.findPosParam(redirectTo, s, posParams) :\n _this.findOrReturn(s, actualSegments); });\n };\n ApplyRedirects.prototype.findPosParam = function (redirectTo, redirectToUrlSegment, posParams) {\n var pos = posParams[redirectToUrlSegment.path.substring(1)];\n if (!pos)\n throw new Error(\"Cannot redirect to '\" + redirectTo + \"'. Cannot find '\" + redirectToUrlSegment.path + \"'.\");\n return pos;\n };\n ApplyRedirects.prototype.findOrReturn = function (redirectToUrlSegment, actualSegments) {\n var e_1, _a;\n var idx = 0;\n try {\n for (var actualSegments_1 = __values(actualSegments), actualSegments_1_1 = actualSegments_1.next(); !actualSegments_1_1.done; actualSegments_1_1 = actualSegments_1.next()) {\n var s = actualSegments_1_1.value;\n if (s.path === redirectToUrlSegment.path) {\n actualSegments.splice(idx);\n return s;\n }\n idx++;\n }\n }\n catch (e_1_1) { e_1 = { error: e_1_1 }; }\n finally {\n try {\n if (actualSegments_1_1 && !actualSegments_1_1.done && (_a = actualSegments_1.return)) _a.call(actualSegments_1);\n }\n finally { if (e_1) throw e_1.error; }\n }\n return redirectToUrlSegment;\n };\n return ApplyRedirects;\n}());\nfunction runCanLoadGuard(moduleInjector, route) {\n var canLoad = route.canLoad;\n if (!canLoad || canLoad.length === 0)\n return of(true);\n var obs = from(canLoad).pipe(map(function (injectionToken) {\n var guard = moduleInjector.get(injectionToken);\n return wrapIntoObservable(guard.canLoad ? guard.canLoad(route) : guard(route));\n }));\n return andObservables(obs);\n}\nfunction match(segmentGroup, route, segments) {\n if (route.path === '') {\n if ((route.pathMatch === 'full') && (segmentGroup.hasChildren() || segments.length > 0)) {\n return { matched: false, consumedSegments: [], lastChild: 0, positionalParamSegments: {} };\n }\n return { matched: true, consumedSegments: [], lastChild: 0, positionalParamSegments: {} };\n }\n var matcher = route.matcher || defaultUrlMatcher;\n var res = matcher(segments, segmentGroup, route);\n if (!res) {\n return {\n matched: false,\n consumedSegments: [],\n lastChild: 0,\n positionalParamSegments: {},\n };\n }\n return {\n matched: true,\n consumedSegments: res.consumed,\n lastChild: res.consumed.length,\n positionalParamSegments: res.posParams,\n };\n}\nfunction split(segmentGroup, consumedSegments, slicedSegments, config) {\n if (slicedSegments.length > 0 &&\n containsEmptyPathRedirectsWithNamedOutlets(segmentGroup, slicedSegments, config)) {\n var s = new UrlSegmentGroup(consumedSegments, createChildrenForEmptySegments(config, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));\n return { segmentGroup: mergeTrivialChildren(s), slicedSegments: [] };\n }\n if (slicedSegments.length === 0 &&\n containsEmptyPathRedirects(segmentGroup, slicedSegments, config)) {\n var s = new UrlSegmentGroup(segmentGroup.segments, addEmptySegmentsToChildrenIfNeeded(segmentGroup, slicedSegments, config, segmentGroup.children));\n return { segmentGroup: mergeTrivialChildren(s), slicedSegments: slicedSegments };\n }\n return { segmentGroup: segmentGroup, slicedSegments: slicedSegments };\n}\nfunction mergeTrivialChildren(s) {\n if (s.numberOfChildren === 1 && s.children[PRIMARY_OUTLET]) {\n var c = s.children[PRIMARY_OUTLET];\n return new UrlSegmentGroup(s.segments.concat(c.segments), c.children);\n }\n return s;\n}\nfunction addEmptySegmentsToChildrenIfNeeded(segmentGroup, slicedSegments, routes, children) {\n var e_2, _a;\n var res = {};\n try {\n for (var routes_1 = __values(routes), routes_1_1 = routes_1.next(); !routes_1_1.done; routes_1_1 = routes_1.next()) {\n var r = routes_1_1.value;\n if (isEmptyPathRedirect(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {\n res[getOutlet(r)] = new UrlSegmentGroup([], {});\n }\n }\n }\n catch (e_2_1) { e_2 = { error: e_2_1 }; }\n finally {\n try {\n if (routes_1_1 && !routes_1_1.done && (_a = routes_1.return)) _a.call(routes_1);\n }\n finally { if (e_2) throw e_2.error; }\n }\n return __assign({}, children, res);\n}\nfunction createChildrenForEmptySegments(routes, primarySegmentGroup) {\n var e_3, _a;\n var res = {};\n res[PRIMARY_OUTLET] = primarySegmentGroup;\n try {\n for (var routes_2 = __values(routes), routes_2_1 = routes_2.next(); !routes_2_1.done; routes_2_1 = routes_2.next()) {\n var r = routes_2_1.value;\n if (r.path === '' && getOutlet(r) !== PRIMARY_OUTLET) {\n res[getOutlet(r)] = new UrlSegmentGroup([], {});\n }\n }\n }\n catch (e_3_1) { e_3 = { error: e_3_1 }; }\n finally {\n try {\n if (routes_2_1 && !routes_2_1.done && (_a = routes_2.return)) _a.call(routes_2);\n }\n finally { if (e_3) throw e_3.error; }\n }\n return res;\n}\nfunction containsEmptyPathRedirectsWithNamedOutlets(segmentGroup, segments, routes) {\n return routes.some(function (r) { return isEmptyPathRedirect(segmentGroup, segments, r) && getOutlet(r) !== PRIMARY_OUTLET; });\n}\nfunction containsEmptyPathRedirects(segmentGroup, segments, routes) {\n return routes.some(function (r) { return isEmptyPathRedirect(segmentGroup, segments, r); });\n}\nfunction isEmptyPathRedirect(segmentGroup, segments, r) {\n if ((segmentGroup.hasChildren() || segments.length > 0) && r.pathMatch === 'full') {\n return false;\n }\n return r.path === '' && r.redirectTo !== undefined;\n}\nfunction getOutlet(route) {\n return route.outlet || PRIMARY_OUTLET;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar Tree = /** @class */ (function () {\n function Tree(root) {\n this._root = root;\n }\n Object.defineProperty(Tree.prototype, \"root\", {\n get: function () { return this._root.value; },\n enumerable: true,\n configurable: true\n });\n /**\n * @internal\n */\n Tree.prototype.parent = function (t) {\n var p = this.pathFromRoot(t);\n return p.length > 1 ? p[p.length - 2] : null;\n };\n /**\n * @internal\n */\n Tree.prototype.children = function (t) {\n var n = findNode(t, this._root);\n return n ? n.children.map(function (t) { return t.value; }) : [];\n };\n /**\n * @internal\n */\n Tree.prototype.firstChild = function (t) {\n var n = findNode(t, this._root);\n return n && n.children.length > 0 ? n.children[0].value : null;\n };\n /**\n * @internal\n */\n Tree.prototype.siblings = function (t) {\n var p = findPath(t, this._root);\n if (p.length < 2)\n return [];\n var c = p[p.length - 2].children.map(function (c) { return c.value; });\n return c.filter(function (cc) { return cc !== t; });\n };\n /**\n * @internal\n */\n Tree.prototype.pathFromRoot = function (t) { return findPath(t, this._root).map(function (s) { return s.value; }); };\n return Tree;\n}());\n// DFS for the node matching the value\nfunction findNode(value, node) {\n var e_1, _a;\n if (value === node.value)\n return node;\n try {\n for (var _b = __values(node.children), _c = _b.next(); !_c.done; _c = _b.next()) {\n var child = _c.value;\n var node_1 = findNode(value, child);\n if (node_1)\n return node_1;\n }\n }\n catch (e_1_1) { e_1 = { error: e_1_1 }; }\n finally {\n try {\n if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n }\n finally { if (e_1) throw e_1.error; }\n }\n return null;\n}\n// Return the path to the node with the given value using DFS\nfunction findPath(value, node) {\n var e_2, _a;\n if (value === node.value)\n return [node];\n try {\n for (var _b = __values(node.children), _c = _b.next(); !_c.done; _c = _b.next()) {\n var child = _c.value;\n var path = findPath(value, child);\n if (path.length) {\n path.unshift(node);\n return path;\n }\n }\n }\n catch (e_2_1) { e_2 = { error: e_2_1 }; }\n finally {\n try {\n if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n }\n finally { if (e_2) throw e_2.error; }\n }\n return [];\n}\nvar TreeNode = /** @class */ (function () {\n function TreeNode(value, children) {\n this.value = value;\n this.children = children;\n }\n TreeNode.prototype.toString = function () { return \"TreeNode(\" + this.value + \")\"; };\n return TreeNode;\n}());\n// Return the list of T indexed by outlet name\nfunction nodeChildrenAsMap(node) {\n var map$$1 = {};\n if (node) {\n node.children.forEach(function (child) { return map$$1[child.value.outlet] = child; });\n }\n return map$$1;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n *\n * Represents the state of the router.\n *\n * RouterState is a tree of activated routes. Every node in this tree knows about the \"consumed\" URL\n * segments, the extracted parameters, and the resolved data.\n *\n * ### Example\n *\n * ```\n * @Component({templateUrl:'template.html'})\n * class MyComponent {\n * constructor(router: Router) {\n * const state: RouterState = router.routerState;\n * const root: ActivatedRoute = state.root;\n * const child = root.firstChild;\n * const id: Observable = child.params.map(p => p.id);\n * //...\n * }\n * }\n * ```\n *\n * See `ActivatedRoute` for more information.\n *\n *\n */\nvar RouterState = /** @class */ (function (_super) {\n __extends(RouterState, _super);\n /** @internal */\n function RouterState(root, \n /** The current snapshot of the router state */\n snapshot) {\n var _this = _super.call(this, root) || this;\n _this.snapshot = snapshot;\n setRouterState(_this, root);\n return _this;\n }\n RouterState.prototype.toString = function () { return this.snapshot.toString(); };\n return RouterState;\n}(Tree));\nfunction createEmptyState(urlTree, rootComponent) {\n var snapshot = createEmptyStateSnapshot(urlTree, rootComponent);\n var emptyUrl = new BehaviorSubject([new UrlSegment('', {})]);\n var emptyParams = new BehaviorSubject({});\n var emptyData = new BehaviorSubject({});\n var emptyQueryParams = new BehaviorSubject({});\n var fragment = new BehaviorSubject('');\n var activated = new ActivatedRoute(emptyUrl, emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, snapshot.root);\n activated.snapshot = snapshot.root;\n return new RouterState(new TreeNode(activated, []), snapshot);\n}\nfunction createEmptyStateSnapshot(urlTree, rootComponent) {\n var emptyParams = {};\n var emptyData = {};\n var emptyQueryParams = {};\n var fragment = '';\n var activated = new ActivatedRouteSnapshot([], emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, null, urlTree.root, -1, {});\n return new RouterStateSnapshot('', new TreeNode(activated, []));\n}\n/**\n * @description\n *\n * Contains the information about a route associated with a component loaded in an\n * outlet. An `ActivatedRoute` can also be used to traverse the router state tree.\n *\n * ```\n * @Component({...})\n * class MyComponent {\n * constructor(route: ActivatedRoute) {\n * const id: Observable = route.params.map(p => p.id);\n * const url: Observable = route.url.map(segments => segments.join(''));\n * // route.data includes both `data` and `resolve`\n * const user = route.data.map(d => d.user);\n * }\n * }\n * ```\n *\n *\n */\nvar ActivatedRoute = /** @class */ (function () {\n /** @internal */\n function ActivatedRoute(\n /** An observable of the URL segments matched by this route */\n url, \n /** An observable of the matrix parameters scoped to this route */\n params, \n /** An observable of the query parameters shared by all the routes */\n queryParams, \n /** An observable of the URL fragment shared by all the routes */\n fragment, \n /** An observable of the static and resolved data of this route. */\n data, \n /** The outlet name of the route. It's a constant */\n outlet, \n /** The component of the route. It's a constant */\n // TODO(vsavkin): remove |string\n component, futureSnapshot) {\n this.url = url;\n this.params = params;\n this.queryParams = queryParams;\n this.fragment = fragment;\n this.data = data;\n this.outlet = outlet;\n this.component = component;\n this._futureSnapshot = futureSnapshot;\n }\n Object.defineProperty(ActivatedRoute.prototype, \"routeConfig\", {\n /** The configuration used to match this route */\n get: function () { return this._futureSnapshot.routeConfig; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRoute.prototype, \"root\", {\n /** The root of the router state */\n get: function () { return this._routerState.root; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRoute.prototype, \"parent\", {\n /** The parent of this route in the router state tree */\n get: function () { return this._routerState.parent(this); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRoute.prototype, \"firstChild\", {\n /** The first child of this route in the router state tree */\n get: function () { return this._routerState.firstChild(this); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRoute.prototype, \"children\", {\n /** The children of this route in the router state tree */\n get: function () { return this._routerState.children(this); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRoute.prototype, \"pathFromRoot\", {\n /** The path from the root of the router state tree to this route */\n get: function () { return this._routerState.pathFromRoot(this); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRoute.prototype, \"paramMap\", {\n get: function () {\n if (!this._paramMap) {\n this._paramMap = this.params.pipe(map(function (p) { return convertToParamMap(p); }));\n }\n return this._paramMap;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRoute.prototype, \"queryParamMap\", {\n get: function () {\n if (!this._queryParamMap) {\n this._queryParamMap =\n this.queryParams.pipe(map(function (p) { return convertToParamMap(p); }));\n }\n return this._queryParamMap;\n },\n enumerable: true,\n configurable: true\n });\n ActivatedRoute.prototype.toString = function () {\n return this.snapshot ? this.snapshot.toString() : \"Future(\" + this._futureSnapshot + \")\";\n };\n return ActivatedRoute;\n}());\n/**\n * Returns the inherited params, data, and resolve for a given route.\n * By default, this only inherits values up to the nearest path-less or component-less route.\n * @internal\n */\nfunction inheritedParamsDataResolve(route, paramsInheritanceStrategy) {\n if (paramsInheritanceStrategy === void 0) { paramsInheritanceStrategy = 'emptyOnly'; }\n var pathFromRoot = route.pathFromRoot;\n var inheritingStartingFrom = 0;\n if (paramsInheritanceStrategy !== 'always') {\n inheritingStartingFrom = pathFromRoot.length - 1;\n while (inheritingStartingFrom >= 1) {\n var current = pathFromRoot[inheritingStartingFrom];\n var parent_1 = pathFromRoot[inheritingStartingFrom - 1];\n // current route is an empty path => inherits its parent's params and data\n if (current.routeConfig && current.routeConfig.path === '') {\n inheritingStartingFrom--;\n // parent is componentless => current route should inherit its params and data\n }\n else if (!parent_1.component) {\n inheritingStartingFrom--;\n }\n else {\n break;\n }\n }\n }\n return flattenInherited(pathFromRoot.slice(inheritingStartingFrom));\n}\n/** @internal */\nfunction flattenInherited(pathFromRoot) {\n return pathFromRoot.reduce(function (res, curr) {\n var params = __assign({}, res.params, curr.params);\n var data = __assign({}, res.data, curr.data);\n var resolve = __assign({}, res.resolve, curr._resolvedData);\n return { params: params, data: data, resolve: resolve };\n }, { params: {}, data: {}, resolve: {} });\n}\n/**\n * @description\n *\n * Contains the information about a route associated with a component loaded in an\n * outlet at a particular moment in time. ActivatedRouteSnapshot can also be used to\n * traverse the router state tree.\n *\n * ```\n * @Component({templateUrl:'./my-component.html'})\n * class MyComponent {\n * constructor(route: ActivatedRoute) {\n * const id: string = route.snapshot.params.id;\n * const url: string = route.snapshot.url.join('');\n * const user = route.snapshot.data.user;\n * }\n * }\n * ```\n *\n *\n */\nvar ActivatedRouteSnapshot = /** @class */ (function () {\n /** @internal */\n function ActivatedRouteSnapshot(\n /** The URL segments matched by this route */\n url, \n /** The matrix parameters scoped to this route */\n params, \n /** The query parameters shared by all the routes */\n queryParams, \n /** The URL fragment shared by all the routes */\n fragment, \n /** The static and resolved data of this route */\n data, \n /** The outlet name of the route */\n outlet, \n /** The component of the route */\n component, routeConfig, urlSegment, lastPathIndex, resolve) {\n this.url = url;\n this.params = params;\n this.queryParams = queryParams;\n this.fragment = fragment;\n this.data = data;\n this.outlet = outlet;\n this.component = component;\n this.routeConfig = routeConfig;\n this._urlSegment = urlSegment;\n this._lastPathIndex = lastPathIndex;\n this._resolve = resolve;\n }\n Object.defineProperty(ActivatedRouteSnapshot.prototype, \"root\", {\n /** The root of the router state */\n get: function () { return this._routerState.root; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRouteSnapshot.prototype, \"parent\", {\n /** The parent of this route in the router state tree */\n get: function () { return this._routerState.parent(this); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRouteSnapshot.prototype, \"firstChild\", {\n /** The first child of this route in the router state tree */\n get: function () { return this._routerState.firstChild(this); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRouteSnapshot.prototype, \"children\", {\n /** The children of this route in the router state tree */\n get: function () { return this._routerState.children(this); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRouteSnapshot.prototype, \"pathFromRoot\", {\n /** The path from the root of the router state tree to this route */\n get: function () { return this._routerState.pathFromRoot(this); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRouteSnapshot.prototype, \"paramMap\", {\n get: function () {\n if (!this._paramMap) {\n this._paramMap = convertToParamMap(this.params);\n }\n return this._paramMap;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ActivatedRouteSnapshot.prototype, \"queryParamMap\", {\n get: function () {\n if (!this._queryParamMap) {\n this._queryParamMap = convertToParamMap(this.queryParams);\n }\n return this._queryParamMap;\n },\n enumerable: true,\n configurable: true\n });\n ActivatedRouteSnapshot.prototype.toString = function () {\n var url = this.url.map(function (segment) { return segment.toString(); }).join('/');\n var matched = this.routeConfig ? this.routeConfig.path : '';\n return \"Route(url:'\" + url + \"', path:'\" + matched + \"')\";\n };\n return ActivatedRouteSnapshot;\n}());\n/**\n * @description\n *\n * Represents the state of the router at a moment in time.\n *\n * This is a tree of activated route snapshots. Every node in this tree knows about\n * the \"consumed\" URL segments, the extracted parameters, and the resolved data.\n *\n * ### Example\n *\n * ```\n * @Component({templateUrl:'template.html'})\n * class MyComponent {\n * constructor(router: Router) {\n * const state: RouterState = router.routerState;\n * const snapshot: RouterStateSnapshot = state.snapshot;\n * const root: ActivatedRouteSnapshot = snapshot.root;\n * const child = root.firstChild;\n * const id: Observable = child.params.map(p => p.id);\n * //...\n * }\n * }\n * ```\n *\n *\n */\nvar RouterStateSnapshot = /** @class */ (function (_super) {\n __extends(RouterStateSnapshot, _super);\n /** @internal */\n function RouterStateSnapshot(\n /** The url from which this snapshot was created */\n url, root) {\n var _this = _super.call(this, root) || this;\n _this.url = url;\n setRouterState(_this, root);\n return _this;\n }\n RouterStateSnapshot.prototype.toString = function () { return serializeNode(this._root); };\n return RouterStateSnapshot;\n}(Tree));\nfunction setRouterState(state, node) {\n node.value._routerState = state;\n node.children.forEach(function (c) { return setRouterState(state, c); });\n}\nfunction serializeNode(node) {\n var c = node.children.length > 0 ? \" { \" + node.children.map(serializeNode).join(', ') + \" } \" : '';\n return \"\" + node.value + c;\n}\n/**\n * The expectation is that the activate route is created with the right set of parameters.\n * So we push new values into the observables only when they are not the initial values.\n * And we detect that by checking if the snapshot field is set.\n */\nfunction advanceActivatedRoute(route) {\n if (route.snapshot) {\n var currentSnapshot = route.snapshot;\n var nextSnapshot = route._futureSnapshot;\n route.snapshot = nextSnapshot;\n if (!shallowEqual(currentSnapshot.queryParams, nextSnapshot.queryParams)) {\n route.queryParams.next(nextSnapshot.queryParams);\n }\n if (currentSnapshot.fragment !== nextSnapshot.fragment) {\n route.fragment.next(nextSnapshot.fragment);\n }\n if (!shallowEqual(currentSnapshot.params, nextSnapshot.params)) {\n route.params.next(nextSnapshot.params);\n }\n if (!shallowEqualArrays(currentSnapshot.url, nextSnapshot.url)) {\n route.url.next(nextSnapshot.url);\n }\n if (!shallowEqual(currentSnapshot.data, nextSnapshot.data)) {\n route.data.next(nextSnapshot.data);\n }\n }\n else {\n route.snapshot = route._futureSnapshot;\n // this is for resolved data\n route.data.next(route._futureSnapshot.data);\n }\n}\nfunction equalParamsAndUrlSegments(a, b) {\n var equalUrlParams = shallowEqual(a.params, b.params) && equalSegments(a.url, b.url);\n var parentsMismatch = !a.parent !== !b.parent;\n return equalUrlParams && !parentsMismatch &&\n (!a.parent || equalParamsAndUrlSegments(a.parent, b.parent));\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction createRouterState(routeReuseStrategy, curr, prevState) {\n var root = createNode(routeReuseStrategy, curr._root, prevState ? prevState._root : undefined);\n return new RouterState(root, curr);\n}\nfunction createNode(routeReuseStrategy, curr, prevState) {\n // reuse an activated route that is currently displayed on the screen\n if (prevState && routeReuseStrategy.shouldReuseRoute(curr.value, prevState.value.snapshot)) {\n var value = prevState.value;\n value._futureSnapshot = curr.value;\n var children = createOrReuseChildren(routeReuseStrategy, curr, prevState);\n return new TreeNode(value, children);\n // retrieve an activated route that is used to be displayed, but is not currently displayed\n }\n else {\n var detachedRouteHandle = routeReuseStrategy.retrieve(curr.value);\n if (detachedRouteHandle) {\n var tree = detachedRouteHandle.route;\n setFutureSnapshotsOfActivatedRoutes(curr, tree);\n return tree;\n }\n else {\n var value = createActivatedRoute(curr.value);\n var children = curr.children.map(function (c) { return createNode(routeReuseStrategy, c); });\n return new TreeNode(value, children);\n }\n }\n}\nfunction setFutureSnapshotsOfActivatedRoutes(curr, result) {\n if (curr.value.routeConfig !== result.value.routeConfig) {\n throw new Error('Cannot reattach ActivatedRouteSnapshot created from a different route');\n }\n if (curr.children.length !== result.children.length) {\n throw new Error('Cannot reattach ActivatedRouteSnapshot with a different number of children');\n }\n result.value._futureSnapshot = curr.value;\n for (var i = 0; i < curr.children.length; ++i) {\n setFutureSnapshotsOfActivatedRoutes(curr.children[i], result.children[i]);\n }\n}\nfunction createOrReuseChildren(routeReuseStrategy, curr, prevState) {\n return curr.children.map(function (child) {\n var e_1, _a;\n try {\n for (var _b = __values(prevState.children), _c = _b.next(); !_c.done; _c = _b.next()) {\n var p = _c.value;\n if (routeReuseStrategy.shouldReuseRoute(p.value.snapshot, child.value)) {\n return createNode(routeReuseStrategy, child, p);\n }\n }\n }\n catch (e_1_1) { e_1 = { error: e_1_1 }; }\n finally {\n try {\n if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n }\n finally { if (e_1) throw e_1.error; }\n }\n return createNode(routeReuseStrategy, child);\n });\n}\nfunction createActivatedRoute(c) {\n return new ActivatedRoute(new BehaviorSubject(c.url), new BehaviorSubject(c.params), new BehaviorSubject(c.queryParams), new BehaviorSubject(c.fragment), new BehaviorSubject(c.data), c.outlet, c.component, c);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction createUrlTree(route, urlTree, commands, queryParams, fragment) {\n if (commands.length === 0) {\n return tree(urlTree.root, urlTree.root, urlTree, queryParams, fragment);\n }\n var nav = computeNavigation(commands);\n if (nav.toRoot()) {\n return tree(urlTree.root, new UrlSegmentGroup([], {}), urlTree, queryParams, fragment);\n }\n var startingPosition = findStartingPosition(nav, urlTree, route);\n var segmentGroup = startingPosition.processChildren ?\n updateSegmentGroupChildren(startingPosition.segmentGroup, startingPosition.index, nav.commands) :\n updateSegmentGroup(startingPosition.segmentGroup, startingPosition.index, nav.commands);\n return tree(startingPosition.segmentGroup, segmentGroup, urlTree, queryParams, fragment);\n}\nfunction isMatrixParams(command) {\n return typeof command === 'object' && command != null && !command.outlets && !command.segmentPath;\n}\nfunction tree(oldSegmentGroup, newSegmentGroup, urlTree, queryParams, fragment) {\n var qp = {};\n if (queryParams) {\n forEach(queryParams, function (value, name) {\n qp[name] = Array.isArray(value) ? value.map(function (v) { return \"\" + v; }) : \"\" + value;\n });\n }\n if (urlTree.root === oldSegmentGroup) {\n return new UrlTree(newSegmentGroup, qp, fragment);\n }\n return new UrlTree(replaceSegment(urlTree.root, oldSegmentGroup, newSegmentGroup), qp, fragment);\n}\nfunction replaceSegment(current, oldSegment, newSegment) {\n var children = {};\n forEach(current.children, function (c, outletName) {\n if (c === oldSegment) {\n children[outletName] = newSegment;\n }\n else {\n children[outletName] = replaceSegment(c, oldSegment, newSegment);\n }\n });\n return new UrlSegmentGroup(current.segments, children);\n}\nvar Navigation = /** @class */ (function () {\n function Navigation(isAbsolute, numberOfDoubleDots, commands) {\n this.isAbsolute = isAbsolute;\n this.numberOfDoubleDots = numberOfDoubleDots;\n this.commands = commands;\n if (isAbsolute && commands.length > 0 && isMatrixParams(commands[0])) {\n throw new Error('Root segment cannot have matrix parameters');\n }\n var cmdWithOutlet = commands.find(function (c) { return typeof c === 'object' && c != null && c.outlets; });\n if (cmdWithOutlet && cmdWithOutlet !== last$1(commands)) {\n throw new Error('{outlets:{}} has to be the last command');\n }\n }\n Navigation.prototype.toRoot = function () {\n return this.isAbsolute && this.commands.length === 1 && this.commands[0] == '/';\n };\n return Navigation;\n}());\n/** Transforms commands to a normalized `Navigation` */\nfunction computeNavigation(commands) {\n if ((typeof commands[0] === 'string') && commands.length === 1 && commands[0] === '/') {\n return new Navigation(true, 0, commands);\n }\n var numberOfDoubleDots = 0;\n var isAbsolute = false;\n var res = commands.reduce(function (res, cmd, cmdIdx) {\n if (typeof cmd === 'object' && cmd != null) {\n if (cmd.outlets) {\n var outlets_1 = {};\n forEach(cmd.outlets, function (commands, name) {\n outlets_1[name] = typeof commands === 'string' ? commands.split('/') : commands;\n });\n return __spread(res, [{ outlets: outlets_1 }]);\n }\n if (cmd.segmentPath) {\n return __spread(res, [cmd.segmentPath]);\n }\n }\n if (!(typeof cmd === 'string')) {\n return __spread(res, [cmd]);\n }\n if (cmdIdx === 0) {\n cmd.split('/').forEach(function (urlPart, partIndex) {\n if (partIndex == 0 && urlPart === '.') ;\n else if (partIndex == 0 && urlPart === '') { // '/a'\n isAbsolute = true;\n }\n else if (urlPart === '..') { // '../a'\n numberOfDoubleDots++;\n }\n else if (urlPart != '') {\n res.push(urlPart);\n }\n });\n return res;\n }\n return __spread(res, [cmd]);\n }, []);\n return new Navigation(isAbsolute, numberOfDoubleDots, res);\n}\nvar Position = /** @class */ (function () {\n function Position(segmentGroup, processChildren, index) {\n this.segmentGroup = segmentGroup;\n this.processChildren = processChildren;\n this.index = index;\n }\n return Position;\n}());\nfunction findStartingPosition(nav, tree, route) {\n if (nav.isAbsolute) {\n return new Position(tree.root, true, 0);\n }\n if (route.snapshot._lastPathIndex === -1) {\n return new Position(route.snapshot._urlSegment, true, 0);\n }\n var modifier = isMatrixParams(nav.commands[0]) ? 0 : 1;\n var index = route.snapshot._lastPathIndex + modifier;\n return createPositionApplyingDoubleDots(route.snapshot._urlSegment, index, nav.numberOfDoubleDots);\n}\nfunction createPositionApplyingDoubleDots(group, index, numberOfDoubleDots) {\n var g = group;\n var ci = index;\n var dd = numberOfDoubleDots;\n while (dd > ci) {\n dd -= ci;\n g = g.parent;\n if (!g) {\n throw new Error('Invalid number of \\'../\\'');\n }\n ci = g.segments.length;\n }\n return new Position(g, false, ci - dd);\n}\nfunction getPath(command) {\n if (typeof command === 'object' && command != null && command.outlets) {\n return command.outlets[PRIMARY_OUTLET];\n }\n return \"\" + command;\n}\nfunction getOutlets(commands) {\n var _a, _b;\n if (!(typeof commands[0] === 'object'))\n return _a = {}, _a[PRIMARY_OUTLET] = commands, _a;\n if (commands[0].outlets === undefined)\n return _b = {}, _b[PRIMARY_OUTLET] = commands, _b;\n return commands[0].outlets;\n}\nfunction updateSegmentGroup(segmentGroup, startIndex, commands) {\n if (!segmentGroup) {\n segmentGroup = new UrlSegmentGroup([], {});\n }\n if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {\n return updateSegmentGroupChildren(segmentGroup, startIndex, commands);\n }\n var m = prefixedWith(segmentGroup, startIndex, commands);\n var slicedCommands = commands.slice(m.commandIndex);\n if (m.match && m.pathIndex < segmentGroup.segments.length) {\n var g = new UrlSegmentGroup(segmentGroup.segments.slice(0, m.pathIndex), {});\n g.children[PRIMARY_OUTLET] =\n new UrlSegmentGroup(segmentGroup.segments.slice(m.pathIndex), segmentGroup.children);\n return updateSegmentGroupChildren(g, 0, slicedCommands);\n }\n else if (m.match && slicedCommands.length === 0) {\n return new UrlSegmentGroup(segmentGroup.segments, {});\n }\n else if (m.match && !segmentGroup.hasChildren()) {\n return createNewSegmentGroup(segmentGroup, startIndex, commands);\n }\n else if (m.match) {\n return updateSegmentGroupChildren(segmentGroup, 0, slicedCommands);\n }\n else {\n return createNewSegmentGroup(segmentGroup, startIndex, commands);\n }\n}\nfunction updateSegmentGroupChildren(segmentGroup, startIndex, commands) {\n if (commands.length === 0) {\n return new UrlSegmentGroup(segmentGroup.segments, {});\n }\n else {\n var outlets_2 = getOutlets(commands);\n var children_1 = {};\n forEach(outlets_2, function (commands, outlet) {\n if (commands !== null) {\n children_1[outlet] = updateSegmentGroup(segmentGroup.children[outlet], startIndex, commands);\n }\n });\n forEach(segmentGroup.children, function (child, childOutlet) {\n if (outlets_2[childOutlet] === undefined) {\n children_1[childOutlet] = child;\n }\n });\n return new UrlSegmentGroup(segmentGroup.segments, children_1);\n }\n}\nfunction prefixedWith(segmentGroup, startIndex, commands) {\n var currentCommandIndex = 0;\n var currentPathIndex = startIndex;\n var noMatch = { match: false, pathIndex: 0, commandIndex: 0 };\n while (currentPathIndex < segmentGroup.segments.length) {\n if (currentCommandIndex >= commands.length)\n return noMatch;\n var path = segmentGroup.segments[currentPathIndex];\n var curr = getPath(commands[currentCommandIndex]);\n var next = currentCommandIndex < commands.length - 1 ? commands[currentCommandIndex + 1] : null;\n if (currentPathIndex > 0 && curr === undefined)\n break;\n if (curr && next && (typeof next === 'object') && next.outlets === undefined) {\n if (!compare(curr, next, path))\n return noMatch;\n currentCommandIndex += 2;\n }\n else {\n if (!compare(curr, {}, path))\n return noMatch;\n currentCommandIndex++;\n }\n currentPathIndex++;\n }\n return { match: true, pathIndex: currentPathIndex, commandIndex: currentCommandIndex };\n}\nfunction createNewSegmentGroup(segmentGroup, startIndex, commands) {\n var paths = segmentGroup.segments.slice(0, startIndex);\n var i = 0;\n while (i < commands.length) {\n if (typeof commands[i] === 'object' && commands[i].outlets !== undefined) {\n var children = createNewSegmentChildren(commands[i].outlets);\n return new UrlSegmentGroup(paths, children);\n }\n // if we start with an object literal, we need to reuse the path part from the segment\n if (i === 0 && isMatrixParams(commands[0])) {\n var p = segmentGroup.segments[startIndex];\n paths.push(new UrlSegment(p.path, commands[0]));\n i++;\n continue;\n }\n var curr = getPath(commands[i]);\n var next = (i < commands.length - 1) ? commands[i + 1] : null;\n if (curr && next && isMatrixParams(next)) {\n paths.push(new UrlSegment(curr, stringify(next)));\n i += 2;\n }\n else {\n paths.push(new UrlSegment(curr, {}));\n i++;\n }\n }\n return new UrlSegmentGroup(paths, {});\n}\nfunction createNewSegmentChildren(outlets) {\n var children = {};\n forEach(outlets, function (commands, outlet) {\n if (commands !== null) {\n children[outlet] = createNewSegmentGroup(new UrlSegmentGroup([], {}), 0, commands);\n }\n });\n return children;\n}\nfunction stringify(params) {\n var res = {};\n forEach(params, function (v, k) { return res[k] = \"\" + v; });\n return res;\n}\nfunction compare(path, params, segment) {\n return path == segment.path && shallowEqual(params, segment.parameters);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar CanActivate = /** @class */ (function () {\n function CanActivate(path) {\n this.path = path;\n this.route = this.path[this.path.length - 1];\n }\n return CanActivate;\n}());\nvar CanDeactivate = /** @class */ (function () {\n function CanDeactivate(component, route) {\n this.component = component;\n this.route = route;\n }\n return CanDeactivate;\n}());\n/**\n * This class bundles the actions involved in preactivation of a route.\n */\nvar PreActivation = /** @class */ (function () {\n function PreActivation(future, curr, moduleInjector, forwardEvent) {\n this.future = future;\n this.curr = curr;\n this.moduleInjector = moduleInjector;\n this.forwardEvent = forwardEvent;\n this.canActivateChecks = [];\n this.canDeactivateChecks = [];\n }\n PreActivation.prototype.initialize = function (parentContexts) {\n var futureRoot = this.future._root;\n var currRoot = this.curr ? this.curr._root : null;\n this.setupChildRouteGuards(futureRoot, currRoot, parentContexts, [futureRoot.value]);\n };\n PreActivation.prototype.checkGuards = function () {\n var _this = this;\n if (!this.isDeactivating() && !this.isActivating()) {\n return of(true);\n }\n var canDeactivate$ = this.runCanDeactivateChecks();\n return canDeactivate$.pipe(mergeMap(function (canDeactivate) { return canDeactivate ? _this.runCanActivateChecks() : of(false); }));\n };\n PreActivation.prototype.resolveData = function (paramsInheritanceStrategy) {\n var _this = this;\n if (!this.isActivating())\n return of(null);\n return from(this.canActivateChecks)\n .pipe(concatMap(function (check) { return _this.runResolve(check.route, paramsInheritanceStrategy); }), reduce(function (_, __) { return _; }));\n };\n PreActivation.prototype.isDeactivating = function () { return this.canDeactivateChecks.length !== 0; };\n PreActivation.prototype.isActivating = function () { return this.canActivateChecks.length !== 0; };\n /**\n * Iterates over child routes and calls recursive `setupRouteGuards` to get `this` instance in\n * proper state to run `checkGuards()` method.\n */\n PreActivation.prototype.setupChildRouteGuards = function (futureNode, currNode, contexts, futurePath) {\n var _this = this;\n var prevChildren = nodeChildrenAsMap(currNode);\n // Process the children of the future route\n futureNode.children.forEach(function (c) {\n _this.setupRouteGuards(c, prevChildren[c.value.outlet], contexts, futurePath.concat([c.value]));\n delete prevChildren[c.value.outlet];\n });\n // Process any children left from the current route (not active for the future route)\n forEach(prevChildren, function (v, k) {\n return _this.deactivateRouteAndItsChildren(v, contexts.getContext(k));\n });\n };\n /**\n * Iterates over child routes and calls recursive `setupRouteGuards` to get `this` instance in\n * proper state to run `checkGuards()` method.\n */\n PreActivation.prototype.setupRouteGuards = function (futureNode, currNode, parentContexts, futurePath) {\n var future = futureNode.value;\n var curr = currNode ? currNode.value : null;\n var context = parentContexts ? parentContexts.getContext(futureNode.value.outlet) : null;\n // reusing the node\n if (curr && future.routeConfig === curr.routeConfig) {\n var shouldRunGuardsAndResolvers = this.shouldRunGuardsAndResolvers(curr, future, future.routeConfig.runGuardsAndResolvers);\n if (shouldRunGuardsAndResolvers) {\n this.canActivateChecks.push(new CanActivate(futurePath));\n }\n else {\n // we need to set the data\n future.data = curr.data;\n future._resolvedData = curr._resolvedData;\n }\n // If we have a component, we need to go through an outlet.\n if (future.component) {\n this.setupChildRouteGuards(futureNode, currNode, context ? context.children : null, futurePath);\n // if we have a componentless route, we recurse but keep the same outlet map.\n }\n else {\n this.setupChildRouteGuards(futureNode, currNode, parentContexts, futurePath);\n }\n if (shouldRunGuardsAndResolvers) {\n var outlet = context.outlet;\n this.canDeactivateChecks.push(new CanDeactivate(outlet.component, curr));\n }\n }\n else {\n if (curr) {\n this.deactivateRouteAndItsChildren(currNode, context);\n }\n this.canActivateChecks.push(new CanActivate(futurePath));\n // If we have a component, we need to go through an outlet.\n if (future.component) {\n this.setupChildRouteGuards(futureNode, null, context ? context.children : null, futurePath);\n // if we have a componentless route, we recurse but keep the same outlet map.\n }\n else {\n this.setupChildRouteGuards(futureNode, null, parentContexts, futurePath);\n }\n }\n };\n PreActivation.prototype.shouldRunGuardsAndResolvers = function (curr, future, mode) {\n switch (mode) {\n case 'always':\n return true;\n case 'paramsOrQueryParamsChange':\n return !equalParamsAndUrlSegments(curr, future) ||\n !shallowEqual(curr.queryParams, future.queryParams);\n case 'paramsChange':\n default:\n return !equalParamsAndUrlSegments(curr, future);\n }\n };\n PreActivation.prototype.deactivateRouteAndItsChildren = function (route, context) {\n var _this = this;\n var children = nodeChildrenAsMap(route);\n var r = route.value;\n forEach(children, function (node, childName) {\n if (!r.component) {\n _this.deactivateRouteAndItsChildren(node, context);\n }\n else if (context) {\n _this.deactivateRouteAndItsChildren(node, context.children.getContext(childName));\n }\n else {\n _this.deactivateRouteAndItsChildren(node, null);\n }\n });\n if (!r.component) {\n this.canDeactivateChecks.push(new CanDeactivate(null, r));\n }\n else if (context && context.outlet && context.outlet.isActivated) {\n this.canDeactivateChecks.push(new CanDeactivate(context.outlet.component, r));\n }\n else {\n this.canDeactivateChecks.push(new CanDeactivate(null, r));\n }\n };\n PreActivation.prototype.runCanDeactivateChecks = function () {\n var _this = this;\n return from(this.canDeactivateChecks)\n .pipe(mergeMap(function (check) { return _this.runCanDeactivate(check.component, check.route); }), every(function (result) { return result === true; }));\n };\n PreActivation.prototype.runCanActivateChecks = function () {\n var _this = this;\n return from(this.canActivateChecks)\n .pipe(concatMap(function (check) { return andObservables(from([\n _this.fireChildActivationStart(check.route.parent),\n _this.fireActivationStart(check.route), _this.runCanActivateChild(check.path),\n _this.runCanActivate(check.route)\n ])); }), every(function (result) { return result === true; }));\n // this.fireChildActivationStart(check.path),\n };\n /**\n * This should fire off `ActivationStart` events for each route being activated at this\n * level.\n * In other words, if you're activating `a` and `b` below, `path` will contain the\n * `ActivatedRouteSnapshot`s for both and we will fire `ActivationStart` for both. Always\n * return\n * `true` so checks continue to run.\n */\n PreActivation.prototype.fireActivationStart = function (snapshot) {\n if (snapshot !== null && this.forwardEvent) {\n this.forwardEvent(new ActivationStart(snapshot));\n }\n return of(true);\n };\n /**\n * This should fire off `ChildActivationStart` events for each route being activated at this\n * level.\n * In other words, if you're activating `a` and `b` below, `path` will contain the\n * `ActivatedRouteSnapshot`s for both and we will fire `ChildActivationStart` for both. Always\n * return\n * `true` so checks continue to run.\n */\n PreActivation.prototype.fireChildActivationStart = function (snapshot) {\n if (snapshot !== null && this.forwardEvent) {\n this.forwardEvent(new ChildActivationStart(snapshot));\n }\n return of(true);\n };\n PreActivation.prototype.runCanActivate = function (future) {\n var _this = this;\n var canActivate = future.routeConfig ? future.routeConfig.canActivate : null;\n if (!canActivate || canActivate.length === 0)\n return of(true);\n var obs = from(canActivate).pipe(map(function (c) {\n var guard = _this.getToken(c, future);\n var observable;\n if (guard.canActivate) {\n observable = wrapIntoObservable(guard.canActivate(future, _this.future));\n }\n else {\n observable = wrapIntoObservable(guard(future, _this.future));\n }\n return observable.pipe(first());\n }));\n return andObservables(obs);\n };\n PreActivation.prototype.runCanActivateChild = function (path) {\n var _this = this;\n var future = path[path.length - 1];\n var canActivateChildGuards = path.slice(0, path.length - 1)\n .reverse()\n .map(function (p) { return _this.extractCanActivateChild(p); })\n .filter(function (_) { return _ !== null; });\n return andObservables(from(canActivateChildGuards).pipe(map(function (d) {\n var obs = from(d.guards).pipe(map(function (c) {\n var guard = _this.getToken(c, d.node);\n var observable;\n if (guard.canActivateChild) {\n observable = wrapIntoObservable(guard.canActivateChild(future, _this.future));\n }\n else {\n observable = wrapIntoObservable(guard(future, _this.future));\n }\n return observable.pipe(first());\n }));\n return andObservables(obs);\n })));\n };\n PreActivation.prototype.extractCanActivateChild = function (p) {\n var canActivateChild = p.routeConfig ? p.routeConfig.canActivateChild : null;\n if (!canActivateChild || canActivateChild.length === 0)\n return null;\n return { node: p, guards: canActivateChild };\n };\n PreActivation.prototype.runCanDeactivate = function (component, curr) {\n var _this = this;\n var canDeactivate = curr && curr.routeConfig ? curr.routeConfig.canDeactivate : null;\n if (!canDeactivate || canDeactivate.length === 0)\n return of(true);\n var canDeactivate$ = from(canDeactivate).pipe(mergeMap(function (c) {\n var guard = _this.getToken(c, curr);\n var observable;\n if (guard.canDeactivate) {\n observable =\n wrapIntoObservable(guard.canDeactivate(component, curr, _this.curr, _this.future));\n }\n else {\n observable = wrapIntoObservable(guard(component, curr, _this.curr, _this.future));\n }\n return observable.pipe(first());\n }));\n return canDeactivate$.pipe(every(function (result) { return result === true; }));\n };\n PreActivation.prototype.runResolve = function (future, paramsInheritanceStrategy) {\n var resolve = future._resolve;\n return this.resolveNode(resolve, future).pipe(map(function (resolvedData) {\n future._resolvedData = resolvedData;\n future.data = __assign({}, future.data, inheritedParamsDataResolve(future, paramsInheritanceStrategy).resolve);\n return null;\n }));\n };\n PreActivation.prototype.resolveNode = function (resolve, future) {\n var _this = this;\n var keys = Object.keys(resolve);\n if (keys.length === 0) {\n return of({});\n }\n if (keys.length === 1) {\n var key_1 = keys[0];\n return this.getResolver(resolve[key_1], future).pipe(map(function (value) {\n var _a;\n return _a = {}, _a[key_1] = value, _a;\n }));\n }\n var data = {};\n var runningResolvers$ = from(keys).pipe(mergeMap(function (key) {\n return _this.getResolver(resolve[key], future).pipe(map(function (value) {\n data[key] = value;\n return value;\n }));\n }));\n return runningResolvers$.pipe(last(), map(function () { return data; }));\n };\n PreActivation.prototype.getResolver = function (injectionToken, future) {\n var resolver = this.getToken(injectionToken, future);\n return resolver.resolve ? wrapIntoObservable(resolver.resolve(future, this.future)) :\n wrapIntoObservable(resolver(future, this.future));\n };\n PreActivation.prototype.getToken = function (token, snapshot) {\n var config = closestLoadedConfig(snapshot);\n var injector = config ? config.module.injector : this.moduleInjector;\n return injector.get(token);\n };\n return PreActivation;\n}());\nfunction closestLoadedConfig(snapshot) {\n if (!snapshot)\n return null;\n for (var s = snapshot.parent; s; s = s.parent) {\n var route = s.routeConfig;\n if (route && route._loadedConfig)\n return route._loadedConfig;\n }\n return null;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar NoMatch$1 = /** @class */ (function () {\n function NoMatch() {\n }\n return NoMatch;\n}());\nfunction recognize(rootComponentType, config, urlTree, url, paramsInheritanceStrategy, relativeLinkResolution) {\n if (paramsInheritanceStrategy === void 0) { paramsInheritanceStrategy = 'emptyOnly'; }\n if (relativeLinkResolution === void 0) { relativeLinkResolution = 'legacy'; }\n return new Recognizer(rootComponentType, config, urlTree, url, paramsInheritanceStrategy, relativeLinkResolution)\n .recognize();\n}\nvar Recognizer = /** @class */ (function () {\n function Recognizer(rootComponentType, config, urlTree, url, paramsInheritanceStrategy, relativeLinkResolution) {\n this.rootComponentType = rootComponentType;\n this.config = config;\n this.urlTree = urlTree;\n this.url = url;\n this.paramsInheritanceStrategy = paramsInheritanceStrategy;\n this.relativeLinkResolution = relativeLinkResolution;\n }\n Recognizer.prototype.recognize = function () {\n try {\n var rootSegmentGroup = split$1(this.urlTree.root, [], [], this.config, this.relativeLinkResolution).segmentGroup;\n var children = this.processSegmentGroup(this.config, rootSegmentGroup, PRIMARY_OUTLET);\n var root = new ActivatedRouteSnapshot([], Object.freeze({}), Object.freeze(__assign({}, this.urlTree.queryParams)), this.urlTree.fragment, {}, PRIMARY_OUTLET, this.rootComponentType, null, this.urlTree.root, -1, {});\n var rootNode = new TreeNode(root, children);\n var routeState = new RouterStateSnapshot(this.url, rootNode);\n this.inheritParamsAndData(routeState._root);\n return of(routeState);\n }\n catch (e) {\n return new Observable(function (obs) { return obs.error(e); });\n }\n };\n Recognizer.prototype.inheritParamsAndData = function (routeNode) {\n var _this = this;\n var route = routeNode.value;\n var i = inheritedParamsDataResolve(route, this.paramsInheritanceStrategy);\n route.params = Object.freeze(i.params);\n route.data = Object.freeze(i.data);\n routeNode.children.forEach(function (n) { return _this.inheritParamsAndData(n); });\n };\n Recognizer.prototype.processSegmentGroup = function (config, segmentGroup, outlet) {\n if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {\n return this.processChildren(config, segmentGroup);\n }\n return this.processSegment(config, segmentGroup, segmentGroup.segments, outlet);\n };\n Recognizer.prototype.processChildren = function (config, segmentGroup) {\n var _this = this;\n var children = mapChildrenIntoArray(segmentGroup, function (child, childOutlet) { return _this.processSegmentGroup(config, child, childOutlet); });\n checkOutletNameUniqueness(children);\n sortActivatedRouteSnapshots(children);\n return children;\n };\n Recognizer.prototype.processSegment = function (config, segmentGroup, segments, outlet) {\n var e_1, _a;\n try {\n for (var config_1 = __values(config), config_1_1 = config_1.next(); !config_1_1.done; config_1_1 = config_1.next()) {\n var r = config_1_1.value;\n try {\n return this.processSegmentAgainstRoute(r, segmentGroup, segments, outlet);\n }\n catch (e) {\n if (!(e instanceof NoMatch$1))\n throw e;\n }\n }\n }\n catch (e_1_1) { e_1 = { error: e_1_1 }; }\n finally {\n try {\n if (config_1_1 && !config_1_1.done && (_a = config_1.return)) _a.call(config_1);\n }\n finally { if (e_1) throw e_1.error; }\n }\n if (this.noLeftoversInUrl(segmentGroup, segments, outlet)) {\n return [];\n }\n throw new NoMatch$1();\n };\n Recognizer.prototype.noLeftoversInUrl = function (segmentGroup, segments, outlet) {\n return segments.length === 0 && !segmentGroup.children[outlet];\n };\n Recognizer.prototype.processSegmentAgainstRoute = function (route, rawSegment, segments, outlet) {\n if (route.redirectTo)\n throw new NoMatch$1();\n if ((route.outlet || PRIMARY_OUTLET) !== outlet)\n throw new NoMatch$1();\n var snapshot;\n var consumedSegments = [];\n var rawSlicedSegments = [];\n if (route.path === '**') {\n var params = segments.length > 0 ? last$1(segments).parameters : {};\n snapshot = new ActivatedRouteSnapshot(segments, params, Object.freeze(__assign({}, this.urlTree.queryParams)), this.urlTree.fragment, getData(route), outlet, route.component, route, getSourceSegmentGroup(rawSegment), getPathIndexShift(rawSegment) + segments.length, getResolve(route));\n }\n else {\n var result = match$1(rawSegment, route, segments);\n consumedSegments = result.consumedSegments;\n rawSlicedSegments = segments.slice(result.lastChild);\n snapshot = new ActivatedRouteSnapshot(consumedSegments, result.parameters, Object.freeze(__assign({}, this.urlTree.queryParams)), this.urlTree.fragment, getData(route), outlet, route.component, route, getSourceSegmentGroup(rawSegment), getPathIndexShift(rawSegment) + consumedSegments.length, getResolve(route));\n }\n var childConfig = getChildConfig(route);\n var _a = split$1(rawSegment, consumedSegments, rawSlicedSegments, childConfig, this.relativeLinkResolution), segmentGroup = _a.segmentGroup, slicedSegments = _a.slicedSegments;\n if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {\n var children_1 = this.processChildren(childConfig, segmentGroup);\n return [new TreeNode(snapshot, children_1)];\n }\n if (childConfig.length === 0 && slicedSegments.length === 0) {\n return [new TreeNode(snapshot, [])];\n }\n var children = this.processSegment(childConfig, segmentGroup, slicedSegments, PRIMARY_OUTLET);\n return [new TreeNode(snapshot, children)];\n };\n return Recognizer;\n}());\nfunction sortActivatedRouteSnapshots(nodes) {\n nodes.sort(function (a, b) {\n if (a.value.outlet === PRIMARY_OUTLET)\n return -1;\n if (b.value.outlet === PRIMARY_OUTLET)\n return 1;\n return a.value.outlet.localeCompare(b.value.outlet);\n });\n}\nfunction getChildConfig(route) {\n if (route.children) {\n return route.children;\n }\n if (route.loadChildren) {\n return route._loadedConfig.routes;\n }\n return [];\n}\nfunction match$1(segmentGroup, route, segments) {\n if (route.path === '') {\n if (route.pathMatch === 'full' && (segmentGroup.hasChildren() || segments.length > 0)) {\n throw new NoMatch$1();\n }\n return { consumedSegments: [], lastChild: 0, parameters: {} };\n }\n var matcher = route.matcher || defaultUrlMatcher;\n var res = matcher(segments, segmentGroup, route);\n if (!res)\n throw new NoMatch$1();\n var posParams = {};\n forEach(res.posParams, function (v, k) { posParams[k] = v.path; });\n var parameters = res.consumed.length > 0 ? __assign({}, posParams, res.consumed[res.consumed.length - 1].parameters) :\n posParams;\n return { consumedSegments: res.consumed, lastChild: res.consumed.length, parameters: parameters };\n}\nfunction checkOutletNameUniqueness(nodes) {\n var names = {};\n nodes.forEach(function (n) {\n var routeWithSameOutletName = names[n.value.outlet];\n if (routeWithSameOutletName) {\n var p = routeWithSameOutletName.url.map(function (s) { return s.toString(); }).join('/');\n var c = n.value.url.map(function (s) { return s.toString(); }).join('/');\n throw new Error(\"Two segments cannot have the same outlet name: '\" + p + \"' and '\" + c + \"'.\");\n }\n names[n.value.outlet] = n.value;\n });\n}\nfunction getSourceSegmentGroup(segmentGroup) {\n var s = segmentGroup;\n while (s._sourceSegment) {\n s = s._sourceSegment;\n }\n return s;\n}\nfunction getPathIndexShift(segmentGroup) {\n var s = segmentGroup;\n var res = (s._segmentIndexShift ? s._segmentIndexShift : 0);\n while (s._sourceSegment) {\n s = s._sourceSegment;\n res += (s._segmentIndexShift ? s._segmentIndexShift : 0);\n }\n return res - 1;\n}\nfunction split$1(segmentGroup, consumedSegments, slicedSegments, config, relativeLinkResolution) {\n if (slicedSegments.length > 0 &&\n containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, config)) {\n var s_1 = new UrlSegmentGroup(consumedSegments, createChildrenForEmptyPaths(segmentGroup, consumedSegments, config, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));\n s_1._sourceSegment = segmentGroup;\n s_1._segmentIndexShift = consumedSegments.length;\n return { segmentGroup: s_1, slicedSegments: [] };\n }\n if (slicedSegments.length === 0 &&\n containsEmptyPathMatches(segmentGroup, slicedSegments, config)) {\n var s_2 = new UrlSegmentGroup(segmentGroup.segments, addEmptyPathsToChildrenIfNeeded(segmentGroup, consumedSegments, slicedSegments, config, segmentGroup.children, relativeLinkResolution));\n s_2._sourceSegment = segmentGroup;\n s_2._segmentIndexShift = consumedSegments.length;\n return { segmentGroup: s_2, slicedSegments: slicedSegments };\n }\n var s = new UrlSegmentGroup(segmentGroup.segments, segmentGroup.children);\n s._sourceSegment = segmentGroup;\n s._segmentIndexShift = consumedSegments.length;\n return { segmentGroup: s, slicedSegments: slicedSegments };\n}\nfunction addEmptyPathsToChildrenIfNeeded(segmentGroup, consumedSegments, slicedSegments, routes, children, relativeLinkResolution) {\n var e_2, _a;\n var res = {};\n try {\n for (var routes_1 = __values(routes), routes_1_1 = routes_1.next(); !routes_1_1.done; routes_1_1 = routes_1.next()) {\n var r = routes_1_1.value;\n if (emptyPathMatch(segmentGroup, slicedSegments, r) && !children[getOutlet$1(r)]) {\n var s = new UrlSegmentGroup([], {});\n s._sourceSegment = segmentGroup;\n if (relativeLinkResolution === 'legacy') {\n s._segmentIndexShift = segmentGroup.segments.length;\n }\n else {\n s._segmentIndexShift = consumedSegments.length;\n }\n res[getOutlet$1(r)] = s;\n }\n }\n }\n catch (e_2_1) { e_2 = { error: e_2_1 }; }\n finally {\n try {\n if (routes_1_1 && !routes_1_1.done && (_a = routes_1.return)) _a.call(routes_1);\n }\n finally { if (e_2) throw e_2.error; }\n }\n return __assign({}, children, res);\n}\nfunction createChildrenForEmptyPaths(segmentGroup, consumedSegments, routes, primarySegment) {\n var e_3, _a;\n var res = {};\n res[PRIMARY_OUTLET] = primarySegment;\n primarySegment._sourceSegment = segmentGroup;\n primarySegment._segmentIndexShift = consumedSegments.length;\n try {\n for (var routes_2 = __values(routes), routes_2_1 = routes_2.next(); !routes_2_1.done; routes_2_1 = routes_2.next()) {\n var r = routes_2_1.value;\n if (r.path === '' && getOutlet$1(r) !== PRIMARY_OUTLET) {\n var s = new UrlSegmentGroup([], {});\n s._sourceSegment = segmentGroup;\n s._segmentIndexShift = consumedSegments.length;\n res[getOutlet$1(r)] = s;\n }\n }\n }\n catch (e_3_1) { e_3 = { error: e_3_1 }; }\n finally {\n try {\n if (routes_2_1 && !routes_2_1.done && (_a = routes_2.return)) _a.call(routes_2);\n }\n finally { if (e_3) throw e_3.error; }\n }\n return res;\n}\nfunction containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, routes) {\n return routes.some(function (r) { return emptyPathMatch(segmentGroup, slicedSegments, r) && getOutlet$1(r) !== PRIMARY_OUTLET; });\n}\nfunction containsEmptyPathMatches(segmentGroup, slicedSegments, routes) {\n return routes.some(function (r) { return emptyPathMatch(segmentGroup, slicedSegments, r); });\n}\nfunction emptyPathMatch(segmentGroup, slicedSegments, r) {\n if ((segmentGroup.hasChildren() || slicedSegments.length > 0) && r.pathMatch === 'full') {\n return false;\n }\n return r.path === '' && r.redirectTo === undefined;\n}\nfunction getOutlet$1(route) {\n return route.outlet || PRIMARY_OUTLET;\n}\nfunction getData(route) {\n return route.data || {};\n}\nfunction getResolve(route) {\n return route.resolve || {};\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n *\n * Provides a way to customize when activated routes get reused.\n *\n * @experimental\n */\nvar RouteReuseStrategy = /** @class */ (function () {\n function RouteReuseStrategy() {\n }\n return RouteReuseStrategy;\n}());\n/**\n * Does not detach any subtrees. Reuses routes as long as their route config is the same.\n */\nvar DefaultRouteReuseStrategy = /** @class */ (function () {\n function DefaultRouteReuseStrategy() {\n }\n DefaultRouteReuseStrategy.prototype.shouldDetach = function (route) { return false; };\n DefaultRouteReuseStrategy.prototype.store = function (route, detachedTree) { };\n DefaultRouteReuseStrategy.prototype.shouldAttach = function (route) { return false; };\n DefaultRouteReuseStrategy.prototype.retrieve = function (route) { return null; };\n DefaultRouteReuseStrategy.prototype.shouldReuseRoute = function (future, curr) {\n return future.routeConfig === curr.routeConfig;\n };\n return DefaultRouteReuseStrategy;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @docsNotRequired\n * @experimental\n */\nvar ROUTES = new InjectionToken('ROUTES');\nvar RouterConfigLoader = /** @class */ (function () {\n function RouterConfigLoader(loader, compiler, onLoadStartListener, onLoadEndListener) {\n this.loader = loader;\n this.compiler = compiler;\n this.onLoadStartListener = onLoadStartListener;\n this.onLoadEndListener = onLoadEndListener;\n }\n RouterConfigLoader.prototype.load = function (parentInjector, route) {\n var _this = this;\n if (this.onLoadStartListener) {\n this.onLoadStartListener(route);\n }\n var moduleFactory$ = this.loadModuleFactory(route.loadChildren);\n return moduleFactory$.pipe(map(function (factory) {\n if (_this.onLoadEndListener) {\n _this.onLoadEndListener(route);\n }\n var module = factory.create(parentInjector);\n return new LoadedRouterConfig(flatten(module.injector.get(ROUTES)).map(standardizeConfig), module);\n }));\n };\n RouterConfigLoader.prototype.loadModuleFactory = function (loadChildren) {\n var _this = this;\n if (typeof loadChildren === 'string') {\n return from(this.loader.load(loadChildren));\n }\n else {\n return wrapIntoObservable(loadChildren()).pipe(mergeMap(function (t) {\n if (t instanceof NgModuleFactory) {\n return of(t);\n }\n else {\n return from(_this.compiler.compileModuleAsync(t));\n }\n }));\n }\n };\n return RouterConfigLoader;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n *\n * Provides a way to migrate AngularJS applications to Angular.\n *\n * @experimental\n */\nvar UrlHandlingStrategy = /** @class */ (function () {\n function UrlHandlingStrategy() {\n }\n return UrlHandlingStrategy;\n}());\n/**\n * @experimental\n */\nvar DefaultUrlHandlingStrategy = /** @class */ (function () {\n function DefaultUrlHandlingStrategy() {\n }\n DefaultUrlHandlingStrategy.prototype.shouldProcessUrl = function (url) { return true; };\n DefaultUrlHandlingStrategy.prototype.extract = function (url) { return url; };\n DefaultUrlHandlingStrategy.prototype.merge = function (newUrlPart, wholeUrl) { return newUrlPart; };\n return DefaultUrlHandlingStrategy;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction defaultErrorHandler(error) {\n throw error;\n}\nfunction defaultMalformedUriErrorHandler(error, urlSerializer, url) {\n return urlSerializer.parse('/');\n}\n/**\n * @internal\n */\nfunction defaultRouterHook(snapshot, runExtras) {\n return of(null);\n}\n/**\n * @description\n *\n * Provides the navigation and url manipulation capabilities.\n *\n * See `Routes` for more details and examples.\n *\n * @ngModule RouterModule\n *\n *\n */\nvar Router = /** @class */ (function () {\n /**\n * Creates the router service.\n */\n // TODO: vsavkin make internal after the final is out.\n function Router(rootComponentType, urlSerializer, rootContexts, location, injector, loader, compiler, config) {\n var _this = this;\n this.rootComponentType = rootComponentType;\n this.urlSerializer = urlSerializer;\n this.rootContexts = rootContexts;\n this.location = location;\n this.config = config;\n this.navigations = new BehaviorSubject(null);\n this.navigationId = 0;\n this.isNgZoneEnabled = false;\n this.events = new Subject();\n /**\n * Error handler that is invoked when a navigation errors.\n *\n * See `ErrorHandler` for more information.\n */\n this.errorHandler = defaultErrorHandler;\n /**\n * Malformed uri error handler is invoked when `Router.parseUrl(url)` throws an\n * error due to containing an invalid character. The most common case would be a `%` sign\n * that's not encoded and is not part of a percent encoded sequence.\n */\n this.malformedUriErrorHandler = defaultMalformedUriErrorHandler;\n /**\n * Indicates if at least one navigation happened.\n */\n this.navigated = false;\n this.lastSuccessfulId = -1;\n /**\n * Used by RouterModule. This allows us to\n * pause the navigation either before preactivation or after it.\n * @internal\n */\n this.hooks = {\n beforePreactivation: defaultRouterHook,\n afterPreactivation: defaultRouterHook\n };\n /**\n * Extracts and merges URLs. Used for AngularJS to Angular migrations.\n */\n this.urlHandlingStrategy = new DefaultUrlHandlingStrategy();\n this.routeReuseStrategy = new DefaultRouteReuseStrategy();\n /**\n * Define what the router should do if it receives a navigation request to the current URL.\n * By default, the router will ignore this navigation. However, this prevents features such\n * as a \"refresh\" button. Use this option to configure the behavior when navigating to the\n * current URL. Default is 'ignore'.\n */\n this.onSameUrlNavigation = 'ignore';\n /**\n * Defines how the router merges params, data and resolved data from parent to child\n * routes. Available options are:\n *\n * - `'emptyOnly'`, the default, only inherits parent params for path-less or component-less\n * routes.\n * - `'always'`, enables unconditional inheritance of parent params.\n */\n this.paramsInheritanceStrategy = 'emptyOnly';\n /**\n * Defines when the router updates the browser URL. The default behavior is to update after\n * successful navigation. However, some applications may prefer a mode where the URL gets\n * updated at the beginning of navigation. The most common use case would be updating the\n * URL early so if navigation fails, you can show an error message with the URL that failed.\n * Available options are:\n *\n * - `'deferred'`, the default, updates the browser URL after navigation has finished.\n * - `'eager'`, updates browser URL at the beginning of navigation.\n */\n this.urlUpdateStrategy = 'deferred';\n /**\n * See {@link RouterModule} for more information.\n */\n this.relativeLinkResolution = 'legacy';\n var onLoadStart = function (r) { return _this.triggerEvent(new RouteConfigLoadStart(r)); };\n var onLoadEnd = function (r) { return _this.triggerEvent(new RouteConfigLoadEnd(r)); };\n this.ngModule = injector.get(NgModuleRef);\n this.console = injector.get(ɵConsole);\n var ngZone = injector.get(NgZone);\n this.isNgZoneEnabled = ngZone instanceof NgZone;\n this.resetConfig(config);\n this.currentUrlTree = createEmptyUrlTree();\n this.rawUrlTree = this.currentUrlTree;\n this.configLoader = new RouterConfigLoader(loader, compiler, onLoadStart, onLoadEnd);\n this.routerState = createEmptyState(this.currentUrlTree, this.rootComponentType);\n this.processNavigations();\n }\n /**\n * @internal\n * TODO: this should be removed once the constructor of the router made internal\n */\n Router.prototype.resetRootComponentType = function (rootComponentType) {\n this.rootComponentType = rootComponentType;\n // TODO: vsavkin router 4.0 should make the root component set to null\n // this will simplify the lifecycle of the router.\n this.routerState.root.component = this.rootComponentType;\n };\n /**\n * Sets up the location change listener and performs the initial navigation.\n */\n Router.prototype.initialNavigation = function () {\n this.setUpLocationChangeListener();\n if (this.navigationId === 0) {\n this.navigateByUrl(this.location.path(true), { replaceUrl: true });\n }\n };\n /**\n * Sets up the location change listener.\n */\n Router.prototype.setUpLocationChangeListener = function () {\n var _this = this;\n // Don't need to use Zone.wrap any more, because zone.js\n // already patch onPopState, so location change callback will\n // run into ngZone\n if (!this.locationSubscription) {\n this.locationSubscription = this.location.subscribe(function (change) {\n var rawUrlTree = _this.parseUrl(change['url']);\n var source = change['type'] === 'popstate' ? 'popstate' : 'hashchange';\n var state = change.state && change.state.navigationId ?\n { navigationId: change.state.navigationId } :\n null;\n setTimeout(function () { _this.scheduleNavigation(rawUrlTree, source, state, { replaceUrl: true }); }, 0);\n });\n }\n };\n Object.defineProperty(Router.prototype, \"url\", {\n /** The current url */\n get: function () { return this.serializeUrl(this.currentUrlTree); },\n enumerable: true,\n configurable: true\n });\n /** @internal */\n Router.prototype.triggerEvent = function (e) { this.events.next(e); };\n /**\n * Resets the configuration used for navigation and generating links.\n *\n * ### Usage\n *\n * ```\n * router.resetConfig([\n * { path: 'team/:id', component: TeamCmp, children: [\n * { path: 'simple', component: SimpleCmp },\n * { path: 'user/:name', component: UserCmp }\n * ]}\n * ]);\n * ```\n */\n Router.prototype.resetConfig = function (config) {\n validateConfig(config);\n this.config = config.map(standardizeConfig);\n this.navigated = false;\n this.lastSuccessfulId = -1;\n };\n /** @docsNotRequired */\n Router.prototype.ngOnDestroy = function () { this.dispose(); };\n /** Disposes of the router */\n Router.prototype.dispose = function () {\n if (this.locationSubscription) {\n this.locationSubscription.unsubscribe();\n this.locationSubscription = null;\n }\n };\n /**\n * Applies an array of commands to the current url tree and creates a new url tree.\n *\n * When given an activate route, applies the given commands starting from the route.\n * When not given a route, applies the given command starting from the root.\n *\n * ### Usage\n *\n * ```\n * // create /team/33/user/11\n * router.createUrlTree(['/team', 33, 'user', 11]);\n *\n * // create /team/33;expand=true/user/11\n * router.createUrlTree(['/team', 33, {expand: true}, 'user', 11]);\n *\n * // you can collapse static segments like this (this works only with the first passed-in value):\n * router.createUrlTree(['/team/33/user', userId]);\n *\n * // If the first segment can contain slashes, and you do not want the router to split it, you\n * // can do the following:\n *\n * router.createUrlTree([{segmentPath: '/one/two'}]);\n *\n * // create /team/33/(user/11//right:chat)\n * router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: 'chat'}}]);\n *\n * // remove the right secondary node\n * router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: null}}]);\n *\n * // assuming the current url is `/team/33/user/11` and the route points to `user/11`\n *\n * // navigate to /team/33/user/11/details\n * router.createUrlTree(['details'], {relativeTo: route});\n *\n * // navigate to /team/33/user/22\n * router.createUrlTree(['../22'], {relativeTo: route});\n *\n * // navigate to /team/44/user/22\n * router.createUrlTree(['../../team/44/user/22'], {relativeTo: route});\n * ```\n */\n Router.prototype.createUrlTree = function (commands, navigationExtras) {\n if (navigationExtras === void 0) { navigationExtras = {}; }\n var relativeTo = navigationExtras.relativeTo, queryParams = navigationExtras.queryParams, fragment = navigationExtras.fragment, preserveQueryParams = navigationExtras.preserveQueryParams, queryParamsHandling = navigationExtras.queryParamsHandling, preserveFragment = navigationExtras.preserveFragment;\n if (isDevMode() && preserveQueryParams && console && console.warn) {\n console.warn('preserveQueryParams is deprecated, use queryParamsHandling instead.');\n }\n var a = relativeTo || this.routerState.root;\n var f = preserveFragment ? this.currentUrlTree.fragment : fragment;\n var q = null;\n if (queryParamsHandling) {\n switch (queryParamsHandling) {\n case 'merge':\n q = __assign({}, this.currentUrlTree.queryParams, queryParams);\n break;\n case 'preserve':\n q = this.currentUrlTree.queryParams;\n break;\n default:\n q = queryParams || null;\n }\n }\n else {\n q = preserveQueryParams ? this.currentUrlTree.queryParams : queryParams || null;\n }\n if (q !== null) {\n q = this.removeEmptyProps(q);\n }\n return createUrlTree(a, this.currentUrlTree, commands, q, f);\n };\n /**\n * Navigate based on the provided url. This navigation is always absolute.\n *\n * Returns a promise that:\n * - resolves to 'true' when navigation succeeds,\n * - resolves to 'false' when navigation fails,\n * - is rejected when an error happens.\n *\n * ### Usage\n *\n * ```\n * router.navigateByUrl(\"/team/33/user/11\");\n *\n * // Navigate without updating the URL\n * router.navigateByUrl(\"/team/33/user/11\", { skipLocationChange: true });\n * ```\n *\n * In opposite to `navigate`, `navigateByUrl` takes a whole URL\n * and does not apply any delta to the current one.\n */\n Router.prototype.navigateByUrl = function (url, extras) {\n if (extras === void 0) { extras = { skipLocationChange: false }; }\n if (isDevMode() && this.isNgZoneEnabled && !NgZone.isInAngularZone()) {\n this.console.warn(\"Navigation triggered outside Angular zone, did you forget to call 'ngZone.run()'?\");\n }\n var urlTree = url instanceof UrlTree ? url : this.parseUrl(url);\n var mergedTree = this.urlHandlingStrategy.merge(urlTree, this.rawUrlTree);\n return this.scheduleNavigation(mergedTree, 'imperative', null, extras);\n };\n /**\n * Navigate based on the provided array of commands and a starting point.\n * If no starting route is provided, the navigation is absolute.\n *\n * Returns a promise that:\n * - resolves to 'true' when navigation succeeds,\n * - resolves to 'false' when navigation fails,\n * - is rejected when an error happens.\n *\n * ### Usage\n *\n * ```\n * router.navigate(['team', 33, 'user', 11], {relativeTo: route});\n *\n * // Navigate without updating the URL\n * router.navigate(['team', 33, 'user', 11], {relativeTo: route, skipLocationChange: true});\n * ```\n *\n * In opposite to `navigateByUrl`, `navigate` always takes a delta that is applied to the current\n * URL.\n */\n Router.prototype.navigate = function (commands, extras) {\n if (extras === void 0) { extras = { skipLocationChange: false }; }\n validateCommands(commands);\n return this.navigateByUrl(this.createUrlTree(commands, extras), extras);\n };\n /** Serializes a `UrlTree` into a string */\n Router.prototype.serializeUrl = function (url) { return this.urlSerializer.serialize(url); };\n /** Parses a string into a `UrlTree` */\n Router.prototype.parseUrl = function (url) {\n var urlTree;\n try {\n urlTree = this.urlSerializer.parse(url);\n }\n catch (e) {\n urlTree = this.malformedUriErrorHandler(e, this.urlSerializer, url);\n }\n return urlTree;\n };\n /** Returns whether the url is activated */\n Router.prototype.isActive = function (url, exact) {\n if (url instanceof UrlTree) {\n return containsTree(this.currentUrlTree, url, exact);\n }\n var urlTree = this.parseUrl(url);\n return containsTree(this.currentUrlTree, urlTree, exact);\n };\n Router.prototype.removeEmptyProps = function (params) {\n return Object.keys(params).reduce(function (result, key) {\n var value = params[key];\n if (value !== null && value !== undefined) {\n result[key] = value;\n }\n return result;\n }, {});\n };\n Router.prototype.processNavigations = function () {\n var _this = this;\n this.navigations\n .pipe(concatMap(function (nav) {\n if (nav) {\n _this.executeScheduledNavigation(nav);\n // a failed navigation should not stop the router from processing\n // further navigations => the catch\n return nav.promise.catch(function () { });\n }\n else {\n return of(null);\n }\n }))\n .subscribe(function () { });\n };\n Router.prototype.scheduleNavigation = function (rawUrl, source, state, extras) {\n var lastNavigation = this.navigations.value;\n // If the user triggers a navigation imperatively (e.g., by using navigateByUrl),\n // and that navigation results in 'replaceState' that leads to the same URL,\n // we should skip those.\n if (lastNavigation && source !== 'imperative' && lastNavigation.source === 'imperative' &&\n lastNavigation.rawUrl.toString() === rawUrl.toString()) {\n return Promise.resolve(true); // return value is not used\n }\n // Because of a bug in IE and Edge, the location class fires two events (popstate and\n // hashchange) every single time. The second one should be ignored. Otherwise, the URL will\n // flicker. Handles the case when a popstate was emitted first.\n if (lastNavigation && source == 'hashchange' && lastNavigation.source === 'popstate' &&\n lastNavigation.rawUrl.toString() === rawUrl.toString()) {\n return Promise.resolve(true); // return value is not used\n }\n // Because of a bug in IE and Edge, the location class fires two events (popstate and\n // hashchange) every single time. The second one should be ignored. Otherwise, the URL will\n // flicker. Handles the case when a hashchange was emitted first.\n if (lastNavigation && source == 'popstate' && lastNavigation.source === 'hashchange' &&\n lastNavigation.rawUrl.toString() === rawUrl.toString()) {\n return Promise.resolve(true); // return value is not used\n }\n var resolve = null;\n var reject = null;\n var promise = new Promise(function (res, rej) {\n resolve = res;\n reject = rej;\n });\n var id = ++this.navigationId;\n this.navigations.next({ id: id, source: source, state: state, rawUrl: rawUrl, extras: extras, resolve: resolve, reject: reject, promise: promise });\n // Make sure that the error is propagated even though `processNavigations` catch\n // handler does not rethrow\n return promise.catch(function (e) { return Promise.reject(e); });\n };\n Router.prototype.executeScheduledNavigation = function (_a) {\n var _this = this;\n var id = _a.id, rawUrl = _a.rawUrl, extras = _a.extras, resolve = _a.resolve, reject = _a.reject, source = _a.source, state = _a.state;\n var url = this.urlHandlingStrategy.extract(rawUrl);\n var urlTransition = !this.navigated || url.toString() !== this.currentUrlTree.toString();\n if ((this.onSameUrlNavigation === 'reload' ? true : urlTransition) &&\n this.urlHandlingStrategy.shouldProcessUrl(rawUrl)) {\n if (this.urlUpdateStrategy === 'eager' && !extras.skipLocationChange) {\n this.setBrowserUrl(rawUrl, !!extras.replaceUrl, id);\n }\n this.events\n .next(new NavigationStart(id, this.serializeUrl(url), source, state));\n Promise.resolve()\n .then(function (_) { return _this.runNavigate(url, rawUrl, !!extras.skipLocationChange, !!extras.replaceUrl, id, null); })\n .then(resolve, reject);\n // we cannot process the current URL, but we could process the previous one =>\n // we need to do some cleanup\n }\n else if (urlTransition && this.rawUrlTree &&\n this.urlHandlingStrategy.shouldProcessUrl(this.rawUrlTree)) {\n this.events\n .next(new NavigationStart(id, this.serializeUrl(url), source, state));\n Promise.resolve()\n .then(function (_) { return _this.runNavigate(url, rawUrl, false, false, id, createEmptyState(url, _this.rootComponentType).snapshot); })\n .then(resolve, reject);\n }\n else {\n this.rawUrlTree = rawUrl;\n resolve(null);\n }\n };\n Router.prototype.runNavigate = function (url, rawUrl, skipLocationChange, replaceUrl, id, precreatedState) {\n var _this = this;\n if (id !== this.navigationId) {\n this.events\n .next(new NavigationCancel(id, this.serializeUrl(url), \"Navigation ID \" + id + \" is not equal to the current navigation id \" + this.navigationId));\n return Promise.resolve(false);\n }\n return new Promise(function (resolvePromise, rejectPromise) {\n // create an observable of the url and route state snapshot\n // this operation do not result in any side effects\n var urlAndSnapshot$;\n if (!precreatedState) {\n var moduleInjector = _this.ngModule.injector;\n var redirectsApplied$ = applyRedirects(moduleInjector, _this.configLoader, _this.urlSerializer, url, _this.config);\n urlAndSnapshot$ = redirectsApplied$.pipe(mergeMap(function (appliedUrl) {\n return recognize(_this.rootComponentType, _this.config, appliedUrl, _this.serializeUrl(appliedUrl), _this.paramsInheritanceStrategy, _this.relativeLinkResolution)\n .pipe(map(function (snapshot) {\n _this.events\n .next(new RoutesRecognized(id, _this.serializeUrl(url), _this.serializeUrl(appliedUrl), snapshot));\n return { appliedUrl: appliedUrl, snapshot: snapshot };\n }));\n }));\n }\n else {\n urlAndSnapshot$ = of({ appliedUrl: url, snapshot: precreatedState });\n }\n var beforePreactivationDone$ = urlAndSnapshot$.pipe(mergeMap(function (p) {\n if (typeof p === 'boolean')\n return of(p);\n return _this.hooks\n .beforePreactivation(p.snapshot, {\n navigationId: id,\n appliedUrlTree: url,\n rawUrlTree: rawUrl, skipLocationChange: skipLocationChange, replaceUrl: replaceUrl,\n })\n .pipe(map(function () { return p; }));\n }));\n // run preactivation: guards and data resolvers\n var preActivation;\n var preactivationSetup$ = beforePreactivationDone$.pipe(map(function (p) {\n if (typeof p === 'boolean')\n return p;\n var appliedUrl = p.appliedUrl, snapshot = p.snapshot;\n var moduleInjector = _this.ngModule.injector;\n preActivation = new PreActivation(snapshot, _this.routerState.snapshot, moduleInjector, function (evt) { return _this.triggerEvent(evt); });\n preActivation.initialize(_this.rootContexts);\n return { appliedUrl: appliedUrl, snapshot: snapshot };\n }));\n var preactivationCheckGuards$ = preactivationSetup$.pipe(mergeMap(function (p) {\n if (typeof p === 'boolean' || _this.navigationId !== id)\n return of(false);\n var appliedUrl = p.appliedUrl, snapshot = p.snapshot;\n _this.triggerEvent(new GuardsCheckStart(id, _this.serializeUrl(url), _this.serializeUrl(appliedUrl), snapshot));\n return preActivation.checkGuards().pipe(map(function (shouldActivate) {\n _this.triggerEvent(new GuardsCheckEnd(id, _this.serializeUrl(url), _this.serializeUrl(appliedUrl), snapshot, shouldActivate));\n return { appliedUrl: appliedUrl, snapshot: snapshot, shouldActivate: shouldActivate };\n }));\n }));\n var preactivationResolveData$ = preactivationCheckGuards$.pipe(mergeMap(function (p) {\n if (typeof p === 'boolean' || _this.navigationId !== id)\n return of(false);\n if (p.shouldActivate && preActivation.isActivating()) {\n _this.triggerEvent(new ResolveStart(id, _this.serializeUrl(url), _this.serializeUrl(p.appliedUrl), p.snapshot));\n return preActivation.resolveData(_this.paramsInheritanceStrategy).pipe(map(function () {\n _this.triggerEvent(new ResolveEnd(id, _this.serializeUrl(url), _this.serializeUrl(p.appliedUrl), p.snapshot));\n return p;\n }));\n }\n else {\n return of(p);\n }\n }));\n var preactivationDone$ = preactivationResolveData$.pipe(mergeMap(function (p) {\n if (typeof p === 'boolean' || _this.navigationId !== id)\n return of(false);\n return _this.hooks\n .afterPreactivation(p.snapshot, {\n navigationId: id,\n appliedUrlTree: url,\n rawUrlTree: rawUrl, skipLocationChange: skipLocationChange, replaceUrl: replaceUrl,\n })\n .pipe(map(function () { return p; }));\n }));\n // create router state\n // this operation has side effects => route state is being affected\n var routerState$ = preactivationDone$.pipe(map(function (p) {\n if (typeof p === 'boolean' || _this.navigationId !== id)\n return false;\n var appliedUrl = p.appliedUrl, snapshot = p.snapshot, shouldActivate = p.shouldActivate;\n if (shouldActivate) {\n var state = createRouterState(_this.routeReuseStrategy, snapshot, _this.routerState);\n return { appliedUrl: appliedUrl, state: state, shouldActivate: shouldActivate };\n }\n else {\n return { appliedUrl: appliedUrl, state: null, shouldActivate: shouldActivate };\n }\n }));\n _this.activateRoutes(routerState$, _this.routerState, _this.currentUrlTree, id, url, rawUrl, skipLocationChange, replaceUrl, resolvePromise, rejectPromise);\n });\n };\n /**\n * Performs the logic of activating routes. This is a synchronous process by default. While this\n * is a private method, it could be overridden to make activation asynchronous.\n */\n Router.prototype.activateRoutes = function (state, storedState, storedUrl, id, url, rawUrl, skipLocationChange, replaceUrl, resolvePromise, rejectPromise) {\n var _this = this;\n // applied the new router state\n // this operation has side effects\n var navigationIsSuccessful;\n state\n .forEach(function (p) {\n if (typeof p === 'boolean' || !p.shouldActivate || id !== _this.navigationId || !p.state) {\n navigationIsSuccessful = false;\n return;\n }\n var appliedUrl = p.appliedUrl, state = p.state;\n _this.currentUrlTree = appliedUrl;\n _this.rawUrlTree = _this.urlHandlingStrategy.merge(_this.currentUrlTree, rawUrl);\n _this.routerState = state;\n if (_this.urlUpdateStrategy === 'deferred' && !skipLocationChange) {\n _this.setBrowserUrl(_this.rawUrlTree, replaceUrl, id);\n }\n new ActivateRoutes(_this.routeReuseStrategy, state, storedState, function (evt) { return _this.triggerEvent(evt); })\n .activate(_this.rootContexts);\n navigationIsSuccessful = true;\n })\n .then(function () {\n if (navigationIsSuccessful) {\n _this.navigated = true;\n _this.lastSuccessfulId = id;\n _this.events\n .next(new NavigationEnd(id, _this.serializeUrl(url), _this.serializeUrl(_this.currentUrlTree)));\n resolvePromise(true);\n }\n else {\n _this.resetUrlToCurrentUrlTree();\n _this.events\n .next(new NavigationCancel(id, _this.serializeUrl(url), ''));\n resolvePromise(false);\n }\n }, function (e) {\n if (isNavigationCancelingError(e)) {\n _this.navigated = true;\n _this.resetStateAndUrl(storedState, storedUrl, rawUrl);\n _this.events\n .next(new NavigationCancel(id, _this.serializeUrl(url), e.message));\n resolvePromise(false);\n }\n else {\n _this.resetStateAndUrl(storedState, storedUrl, rawUrl);\n _this.events\n .next(new NavigationError(id, _this.serializeUrl(url), e));\n try {\n resolvePromise(_this.errorHandler(e));\n }\n catch (ee) {\n rejectPromise(ee);\n }\n }\n });\n };\n Router.prototype.setBrowserUrl = function (url, replaceUrl, id) {\n var path = this.urlSerializer.serialize(url);\n if (this.location.isCurrentPathEqualTo(path) || replaceUrl) {\n this.location.replaceState(path, '', { navigationId: id });\n }\n else {\n this.location.go(path, '', { navigationId: id });\n }\n };\n Router.prototype.resetStateAndUrl = function (storedState, storedUrl, rawUrl) {\n this.routerState = storedState;\n this.currentUrlTree = storedUrl;\n this.rawUrlTree = this.urlHandlingStrategy.merge(this.currentUrlTree, rawUrl);\n this.resetUrlToCurrentUrlTree();\n };\n Router.prototype.resetUrlToCurrentUrlTree = function () {\n this.location.replaceState(this.urlSerializer.serialize(this.rawUrlTree), '', { navigationId: this.lastSuccessfulId });\n };\n return Router;\n}());\nvar ActivateRoutes = /** @class */ (function () {\n function ActivateRoutes(routeReuseStrategy, futureState, currState, forwardEvent) {\n this.routeReuseStrategy = routeReuseStrategy;\n this.futureState = futureState;\n this.currState = currState;\n this.forwardEvent = forwardEvent;\n }\n ActivateRoutes.prototype.activate = function (parentContexts) {\n var futureRoot = this.futureState._root;\n var currRoot = this.currState ? this.currState._root : null;\n this.deactivateChildRoutes(futureRoot, currRoot, parentContexts);\n advanceActivatedRoute(this.futureState.root);\n this.activateChildRoutes(futureRoot, currRoot, parentContexts);\n };\n // De-activate the child route that are not re-used for the future state\n ActivateRoutes.prototype.deactivateChildRoutes = function (futureNode, currNode, contexts) {\n var _this = this;\n var children = nodeChildrenAsMap(currNode);\n // Recurse on the routes active in the future state to de-activate deeper children\n futureNode.children.forEach(function (futureChild) {\n var childOutletName = futureChild.value.outlet;\n _this.deactivateRoutes(futureChild, children[childOutletName], contexts);\n delete children[childOutletName];\n });\n // De-activate the routes that will not be re-used\n forEach(children, function (v, childName) {\n _this.deactivateRouteAndItsChildren(v, contexts);\n });\n };\n ActivateRoutes.prototype.deactivateRoutes = function (futureNode, currNode, parentContext) {\n var future = futureNode.value;\n var curr = currNode ? currNode.value : null;\n if (future === curr) {\n // Reusing the node, check to see if the children need to be de-activated\n if (future.component) {\n // If we have a normal route, we need to go through an outlet.\n var context = parentContext.getContext(future.outlet);\n if (context) {\n this.deactivateChildRoutes(futureNode, currNode, context.children);\n }\n }\n else {\n // if we have a componentless route, we recurse but keep the same outlet map.\n this.deactivateChildRoutes(futureNode, currNode, parentContext);\n }\n }\n else {\n if (curr) {\n // Deactivate the current route which will not be re-used\n this.deactivateRouteAndItsChildren(currNode, parentContext);\n }\n }\n };\n ActivateRoutes.prototype.deactivateRouteAndItsChildren = function (route, parentContexts) {\n if (this.routeReuseStrategy.shouldDetach(route.value.snapshot)) {\n this.detachAndStoreRouteSubtree(route, parentContexts);\n }\n else {\n this.deactivateRouteAndOutlet(route, parentContexts);\n }\n };\n ActivateRoutes.prototype.detachAndStoreRouteSubtree = function (route, parentContexts) {\n var context = parentContexts.getContext(route.value.outlet);\n if (context && context.outlet) {\n var componentRef = context.outlet.detach();\n var contexts = context.children.onOutletDeactivated();\n this.routeReuseStrategy.store(route.value.snapshot, { componentRef: componentRef, route: route, contexts: contexts });\n }\n };\n ActivateRoutes.prototype.deactivateRouteAndOutlet = function (route, parentContexts) {\n var _this = this;\n var context = parentContexts.getContext(route.value.outlet);\n if (context) {\n var children = nodeChildrenAsMap(route);\n var contexts_1 = route.value.component ? context.children : parentContexts;\n forEach(children, function (v, k) { return _this.deactivateRouteAndItsChildren(v, contexts_1); });\n if (context.outlet) {\n // Destroy the component\n context.outlet.deactivate();\n // Destroy the contexts for all the outlets that were in the component\n context.children.onOutletDeactivated();\n }\n }\n };\n ActivateRoutes.prototype.activateChildRoutes = function (futureNode, currNode, contexts) {\n var _this = this;\n var children = nodeChildrenAsMap(currNode);\n futureNode.children.forEach(function (c) {\n _this.activateRoutes(c, children[c.value.outlet], contexts);\n _this.forwardEvent(new ActivationEnd(c.value.snapshot));\n });\n if (futureNode.children.length) {\n this.forwardEvent(new ChildActivationEnd(futureNode.value.snapshot));\n }\n };\n ActivateRoutes.prototype.activateRoutes = function (futureNode, currNode, parentContexts) {\n var future = futureNode.value;\n var curr = currNode ? currNode.value : null;\n advanceActivatedRoute(future);\n // reusing the node\n if (future === curr) {\n if (future.component) {\n // If we have a normal route, we need to go through an outlet.\n var context = parentContexts.getOrCreateContext(future.outlet);\n this.activateChildRoutes(futureNode, currNode, context.children);\n }\n else {\n // if we have a componentless route, we recurse but keep the same outlet map.\n this.activateChildRoutes(futureNode, currNode, parentContexts);\n }\n }\n else {\n if (future.component) {\n // if we have a normal route, we need to place the component into the outlet and recurse.\n var context = parentContexts.getOrCreateContext(future.outlet);\n if (this.routeReuseStrategy.shouldAttach(future.snapshot)) {\n var stored = this.routeReuseStrategy.retrieve(future.snapshot);\n this.routeReuseStrategy.store(future.snapshot, null);\n context.children.onOutletReAttached(stored.contexts);\n context.attachRef = stored.componentRef;\n context.route = stored.route.value;\n if (context.outlet) {\n // Attach right away when the outlet has already been instantiated\n // Otherwise attach from `RouterOutlet.ngOnInit` when it is instantiated\n context.outlet.attach(stored.componentRef, stored.route.value);\n }\n advanceActivatedRouteNodeAndItsChildren(stored.route);\n }\n else {\n var config = parentLoadedConfig(future.snapshot);\n var cmpFactoryResolver = config ? config.module.componentFactoryResolver : null;\n context.route = future;\n context.resolver = cmpFactoryResolver;\n if (context.outlet) {\n // Activate the outlet when it has already been instantiated\n // Otherwise it will get activated from its `ngOnInit` when instantiated\n context.outlet.activateWith(future, cmpFactoryResolver);\n }\n this.activateChildRoutes(futureNode, null, context.children);\n }\n }\n else {\n // if we have a componentless route, we recurse but keep the same outlet map.\n this.activateChildRoutes(futureNode, null, parentContexts);\n }\n }\n };\n return ActivateRoutes;\n}());\nfunction advanceActivatedRouteNodeAndItsChildren(node) {\n advanceActivatedRoute(node.value);\n node.children.forEach(advanceActivatedRouteNodeAndItsChildren);\n}\nfunction parentLoadedConfig(snapshot) {\n for (var s = snapshot.parent; s; s = s.parent) {\n var route = s.routeConfig;\n if (route && route._loadedConfig)\n return route._loadedConfig;\n if (route && route.component)\n return null;\n }\n return null;\n}\nfunction validateCommands(commands) {\n for (var i = 0; i < commands.length; i++) {\n var cmd = commands[i];\n if (cmd == null) {\n throw new Error(\"The requested path contains \" + cmd + \" segment at index \" + i);\n }\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n *\n * Lets you link to specific routes in your app.\n *\n * Consider the following route configuration:\n * `[{ path: 'user/:name', component: UserCmp }]`.\n * When linking to this `user/:name` route, you use the `RouterLink` directive.\n *\n * If the link is static, you can use the directive as follows:\n * `link to user component`\n *\n * If you use dynamic values to generate the link, you can pass an array of path\n * segments, followed by the params for each segment.\n *\n * For instance `['/team', teamId, 'user', userName, {details: true}]`\n * means that we want to generate a link to `/team/11/user/bob;details=true`.\n *\n * Multiple static segments can be merged into one\n * (e.g., `['/team/11/user', userName, {details: true}]`).\n *\n * The first segment name can be prepended with `/`, `./`, or `../`:\n * * If the first segment begins with `/`, the router will look up the route from the root of the\n * app.\n * * If the first segment begins with `./`, or doesn't begin with a slash, the router will\n * instead look in the children of the current activated route.\n * * And if the first segment begins with `../`, the router will go up one level.\n *\n * You can set query params and fragment as follows:\n *\n * ```\n * \n * link to user component\n * \n * ```\n * RouterLink will use these to generate this link: `/user/bob#education?debug=true`.\n *\n * (Deprecated in v4.0.0 use `queryParamsHandling` instead) You can also tell the\n * directive to preserve the current query params and fragment:\n *\n * ```\n * \n * link to user component\n * \n * ```\n *\n * You can tell the directive to how to handle queryParams, available options are:\n * - `'merge'`: merge the queryParams into the current queryParams\n * - `'preserve'`: preserve the current queryParams\n * - default/`''`: use the queryParams only\n *\n * Same options for {@link NavigationExtras#queryParamsHandling\n * NavigationExtras#queryParamsHandling}.\n *\n * ```\n * \n * link to user component\n * \n * ```\n *\n * The router link directive always treats the provided input as a delta to the current url.\n *\n * For instance, if the current url is `/user/(box//aux:team)`.\n *\n * Then the following link `Jim` will generate the link\n * `/user/(jim//aux:team)`.\n *\n * See {@link Router#createUrlTree createUrlTree} for more information.\n *\n * @ngModule RouterModule\n *\n *\n */\nvar RouterLink = /** @class */ (function () {\n function RouterLink(router, route, tabIndex, renderer, el) {\n this.router = router;\n this.route = route;\n this.commands = [];\n if (tabIndex == null) {\n renderer.setAttribute(el.nativeElement, 'tabindex', '0');\n }\n }\n Object.defineProperty(RouterLink.prototype, \"routerLink\", {\n set: function (commands) {\n if (commands != null) {\n this.commands = Array.isArray(commands) ? commands : [commands];\n }\n else {\n this.commands = [];\n }\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RouterLink.prototype, \"preserveQueryParams\", {\n /**\n * @deprecated 4.0.0 use `queryParamsHandling` instead.\n */\n set: function (value) {\n if (isDevMode() && console && console.warn) {\n console.warn('preserveQueryParams is deprecated!, use queryParamsHandling instead.');\n }\n this.preserve = value;\n },\n enumerable: true,\n configurable: true\n });\n RouterLink.prototype.onClick = function () {\n var extras = {\n skipLocationChange: attrBoolValue(this.skipLocationChange),\n replaceUrl: attrBoolValue(this.replaceUrl),\n };\n this.router.navigateByUrl(this.urlTree, extras);\n return true;\n };\n Object.defineProperty(RouterLink.prototype, \"urlTree\", {\n get: function () {\n return this.router.createUrlTree(this.commands, {\n relativeTo: this.route,\n queryParams: this.queryParams,\n fragment: this.fragment,\n preserveQueryParams: attrBoolValue(this.preserve),\n queryParamsHandling: this.queryParamsHandling,\n preserveFragment: attrBoolValue(this.preserveFragment),\n });\n },\n enumerable: true,\n configurable: true\n });\n RouterLink.decorators = [\n { type: Directive, args: [{ selector: ':not(a)[routerLink]' },] }\n ];\n /** @nocollapse */\n RouterLink.ctorParameters = function () { return [\n { type: Router },\n { type: ActivatedRoute },\n { type: String, decorators: [{ type: Attribute, args: ['tabindex',] }] },\n { type: Renderer2 },\n { type: ElementRef }\n ]; };\n RouterLink.propDecorators = {\n queryParams: [{ type: Input }],\n fragment: [{ type: Input }],\n queryParamsHandling: [{ type: Input }],\n preserveFragment: [{ type: Input }],\n skipLocationChange: [{ type: Input }],\n replaceUrl: [{ type: Input }],\n routerLink: [{ type: Input }],\n preserveQueryParams: [{ type: Input }],\n onClick: [{ type: HostListener, args: ['click',] }]\n };\n return RouterLink;\n}());\n/**\n * @description\n *\n * Lets you link to specific routes in your app.\n *\n * See `RouterLink` for more information.\n *\n * @ngModule RouterModule\n *\n *\n */\nvar RouterLinkWithHref = /** @class */ (function () {\n function RouterLinkWithHref(router, route, locationStrategy) {\n var _this = this;\n this.router = router;\n this.route = route;\n this.locationStrategy = locationStrategy;\n this.commands = [];\n this.subscription = router.events.subscribe(function (s) {\n if (s instanceof NavigationEnd) {\n _this.updateTargetUrlAndHref();\n }\n });\n }\n Object.defineProperty(RouterLinkWithHref.prototype, \"routerLink\", {\n set: function (commands) {\n if (commands != null) {\n this.commands = Array.isArray(commands) ? commands : [commands];\n }\n else {\n this.commands = [];\n }\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RouterLinkWithHref.prototype, \"preserveQueryParams\", {\n set: function (value) {\n if (isDevMode() && console && console.warn) {\n console.warn('preserveQueryParams is deprecated, use queryParamsHandling instead.');\n }\n this.preserve = value;\n },\n enumerable: true,\n configurable: true\n });\n RouterLinkWithHref.prototype.ngOnChanges = function (changes) { this.updateTargetUrlAndHref(); };\n RouterLinkWithHref.prototype.ngOnDestroy = function () { this.subscription.unsubscribe(); };\n RouterLinkWithHref.prototype.onClick = function (button, ctrlKey, metaKey, shiftKey) {\n if (button !== 0 || ctrlKey || metaKey || shiftKey) {\n return true;\n }\n if (typeof this.target === 'string' && this.target != '_self') {\n return true;\n }\n var extras = {\n skipLocationChange: attrBoolValue(this.skipLocationChange),\n replaceUrl: attrBoolValue(this.replaceUrl),\n };\n this.router.navigateByUrl(this.urlTree, extras);\n return false;\n };\n RouterLinkWithHref.prototype.updateTargetUrlAndHref = function () {\n this.href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.urlTree));\n };\n Object.defineProperty(RouterLinkWithHref.prototype, \"urlTree\", {\n get: function () {\n return this.router.createUrlTree(this.commands, {\n relativeTo: this.route,\n queryParams: this.queryParams,\n fragment: this.fragment,\n preserveQueryParams: attrBoolValue(this.preserve),\n queryParamsHandling: this.queryParamsHandling,\n preserveFragment: attrBoolValue(this.preserveFragment),\n });\n },\n enumerable: true,\n configurable: true\n });\n RouterLinkWithHref.decorators = [\n { type: Directive, args: [{ selector: 'a[routerLink]' },] }\n ];\n /** @nocollapse */\n RouterLinkWithHref.ctorParameters = function () { return [\n { type: Router },\n { type: ActivatedRoute },\n { type: LocationStrategy }\n ]; };\n RouterLinkWithHref.propDecorators = {\n target: [{ type: HostBinding, args: ['attr.target',] }, { type: Input }],\n queryParams: [{ type: Input }],\n fragment: [{ type: Input }],\n queryParamsHandling: [{ type: Input }],\n preserveFragment: [{ type: Input }],\n skipLocationChange: [{ type: Input }],\n replaceUrl: [{ type: Input }],\n href: [{ type: HostBinding }],\n routerLink: [{ type: Input }],\n preserveQueryParams: [{ type: Input }],\n onClick: [{ type: HostListener, args: ['click', ['$event.button', '$event.ctrlKey', '$event.metaKey', '$event.shiftKey'],] }]\n };\n return RouterLinkWithHref;\n}());\nfunction attrBoolValue(s) {\n return s === '' || !!s;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n *\n * @description\n *\n * Lets you add a CSS class to an element when the link's route becomes active.\n *\n * This directive lets you add a CSS class to an element when the link's route\n * becomes active.\n *\n * Consider the following example:\n *\n * ```\n * Bob\n * ```\n *\n * When the url is either '/user' or '/user/bob', the active-link class will\n * be added to the `a` tag. If the url changes, the class will be removed.\n *\n * You can set more than one class, as follows:\n *\n * ```\n * Bob\n * Bob\n * ```\n *\n * You can configure RouterLinkActive by passing `exact: true`. This will add the classes\n * only when the url matches the link exactly.\n *\n * ```\n * Bob\n * ```\n *\n * You can assign the RouterLinkActive instance to a template variable and directly check\n * the `isActive` status.\n * ```\n * \n * Bob {{ rla.isActive ? '(already open)' : ''}}\n * \n * ```\n *\n * Finally, you can apply the RouterLinkActive directive to an ancestor of a RouterLink.\n *\n * ```\n *
\n * ```\n *\n * This will set the active-link class on the div tag if the url is either '/user/jim' or\n * '/user/bob'.\n *\n * @ngModule RouterModule\n *\n *\n */\nvar RouterLinkActive = /** @class */ (function () {\n function RouterLinkActive(router, element, renderer, cdr) {\n var _this = this;\n this.router = router;\n this.element = element;\n this.renderer = renderer;\n this.cdr = cdr;\n this.classes = [];\n this.isActive = false;\n this.routerLinkActiveOptions = { exact: false };\n this.subscription = router.events.subscribe(function (s) {\n if (s instanceof NavigationEnd) {\n _this.update();\n }\n });\n }\n RouterLinkActive.prototype.ngAfterContentInit = function () {\n var _this = this;\n this.links.changes.subscribe(function (_) { return _this.update(); });\n this.linksWithHrefs.changes.subscribe(function (_) { return _this.update(); });\n this.update();\n };\n Object.defineProperty(RouterLinkActive.prototype, \"routerLinkActive\", {\n set: function (data) {\n var classes = Array.isArray(data) ? data : data.split(' ');\n this.classes = classes.filter(function (c) { return !!c; });\n },\n enumerable: true,\n configurable: true\n });\n RouterLinkActive.prototype.ngOnChanges = function (changes) { this.update(); };\n RouterLinkActive.prototype.ngOnDestroy = function () { this.subscription.unsubscribe(); };\n RouterLinkActive.prototype.update = function () {\n var _this = this;\n if (!this.links || !this.linksWithHrefs || !this.router.navigated)\n return;\n Promise.resolve().then(function () {\n var hasActiveLinks = _this.hasActiveLinks();\n if (_this.isActive !== hasActiveLinks) {\n _this.isActive = hasActiveLinks;\n _this.classes.forEach(function (c) {\n if (hasActiveLinks) {\n _this.renderer.addClass(_this.element.nativeElement, c);\n }\n else {\n _this.renderer.removeClass(_this.element.nativeElement, c);\n }\n });\n }\n });\n };\n RouterLinkActive.prototype.isLinkActive = function (router) {\n var _this = this;\n return function (link) {\n return router.isActive(link.urlTree, _this.routerLinkActiveOptions.exact);\n };\n };\n RouterLinkActive.prototype.hasActiveLinks = function () {\n return this.links.some(this.isLinkActive(this.router)) ||\n this.linksWithHrefs.some(this.isLinkActive(this.router));\n };\n RouterLinkActive.decorators = [\n { type: Directive, args: [{\n selector: '[routerLinkActive]',\n exportAs: 'routerLinkActive',\n },] }\n ];\n /** @nocollapse */\n RouterLinkActive.ctorParameters = function () { return [\n { type: Router },\n { type: ElementRef },\n { type: Renderer2 },\n { type: ChangeDetectorRef }\n ]; };\n RouterLinkActive.propDecorators = {\n links: [{ type: ContentChildren, args: [RouterLink, { descendants: true },] }],\n linksWithHrefs: [{ type: ContentChildren, args: [RouterLinkWithHref, { descendants: true },] }],\n routerLinkActiveOptions: [{ type: Input }],\n routerLinkActive: [{ type: Input }]\n };\n return RouterLinkActive;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Store contextual information about a `RouterOutlet`\n *\n *\n */\nvar OutletContext = /** @class */ (function () {\n function OutletContext() {\n this.outlet = null;\n this.route = null;\n this.resolver = null;\n this.children = new ChildrenOutletContexts();\n this.attachRef = null;\n }\n return OutletContext;\n}());\n/**\n * Store contextual information about the children (= nested) `RouterOutlet`\n *\n *\n */\nvar ChildrenOutletContexts = /** @class */ (function () {\n function ChildrenOutletContexts() {\n // contexts for child outlets, by name.\n this.contexts = new Map();\n }\n /** Called when a `RouterOutlet` directive is instantiated */\n ChildrenOutletContexts.prototype.onChildOutletCreated = function (childName, outlet) {\n var context = this.getOrCreateContext(childName);\n context.outlet = outlet;\n this.contexts.set(childName, context);\n };\n /**\n * Called when a `RouterOutlet` directive is destroyed.\n * We need to keep the context as the outlet could be destroyed inside a NgIf and might be\n * re-created later.\n */\n ChildrenOutletContexts.prototype.onChildOutletDestroyed = function (childName) {\n var context = this.getContext(childName);\n if (context) {\n context.outlet = null;\n }\n };\n /**\n * Called when the corresponding route is deactivated during navigation.\n * Because the component get destroyed, all children outlet are destroyed.\n */\n ChildrenOutletContexts.prototype.onOutletDeactivated = function () {\n var contexts = this.contexts;\n this.contexts = new Map();\n return contexts;\n };\n ChildrenOutletContexts.prototype.onOutletReAttached = function (contexts) { this.contexts = contexts; };\n ChildrenOutletContexts.prototype.getOrCreateContext = function (childName) {\n var context = this.getContext(childName);\n if (!context) {\n context = new OutletContext();\n this.contexts.set(childName, context);\n }\n return context;\n };\n ChildrenOutletContexts.prototype.getContext = function (childName) { return this.contexts.get(childName) || null; };\n return ChildrenOutletContexts;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n *\n * Acts as a placeholder that Angular dynamically fills based on the current router state.\n *\n * ```\n * \n * \n * \n * ```\n *\n * A router outlet will emit an activate event any time a new component is being instantiated,\n * and a deactivate event when it is being destroyed.\n *\n * ```\n * \n * ```\n * @ngModule RouterModule\n *\n *\n */\nvar RouterOutlet = /** @class */ (function () {\n function RouterOutlet(parentContexts, location, resolver, name, changeDetector) {\n this.parentContexts = parentContexts;\n this.location = location;\n this.resolver = resolver;\n this.changeDetector = changeDetector;\n this.activated = null;\n this._activatedRoute = null;\n this.activateEvents = new EventEmitter();\n this.deactivateEvents = new EventEmitter();\n this.name = name || PRIMARY_OUTLET;\n parentContexts.onChildOutletCreated(this.name, this);\n }\n RouterOutlet.prototype.ngOnDestroy = function () { this.parentContexts.onChildOutletDestroyed(this.name); };\n RouterOutlet.prototype.ngOnInit = function () {\n if (!this.activated) {\n // If the outlet was not instantiated at the time the route got activated we need to populate\n // the outlet when it is initialized (ie inside a NgIf)\n var context = this.parentContexts.getContext(this.name);\n if (context && context.route) {\n if (context.attachRef) {\n // `attachRef` is populated when there is an existing component to mount\n this.attach(context.attachRef, context.route);\n }\n else {\n // otherwise the component defined in the configuration is created\n this.activateWith(context.route, context.resolver || null);\n }\n }\n }\n };\n Object.defineProperty(RouterOutlet.prototype, \"isActivated\", {\n get: function () { return !!this.activated; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RouterOutlet.prototype, \"component\", {\n get: function () {\n if (!this.activated)\n throw new Error('Outlet is not activated');\n return this.activated.instance;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RouterOutlet.prototype, \"activatedRoute\", {\n get: function () {\n if (!this.activated)\n throw new Error('Outlet is not activated');\n return this._activatedRoute;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RouterOutlet.prototype, \"activatedRouteData\", {\n get: function () {\n if (this._activatedRoute) {\n return this._activatedRoute.snapshot.data;\n }\n return {};\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Called when the `RouteReuseStrategy` instructs to detach the subtree\n */\n RouterOutlet.prototype.detach = function () {\n if (!this.activated)\n throw new Error('Outlet is not activated');\n this.location.detach();\n var cmp = this.activated;\n this.activated = null;\n this._activatedRoute = null;\n return cmp;\n };\n /**\n * Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree\n */\n RouterOutlet.prototype.attach = function (ref, activatedRoute) {\n this.activated = ref;\n this._activatedRoute = activatedRoute;\n this.location.insert(ref.hostView);\n };\n RouterOutlet.prototype.deactivate = function () {\n if (this.activated) {\n var c = this.component;\n this.activated.destroy();\n this.activated = null;\n this._activatedRoute = null;\n this.deactivateEvents.emit(c);\n }\n };\n RouterOutlet.prototype.activateWith = function (activatedRoute, resolver) {\n if (this.isActivated) {\n throw new Error('Cannot activate an already activated outlet');\n }\n this._activatedRoute = activatedRoute;\n var snapshot = activatedRoute._futureSnapshot;\n var component = snapshot.routeConfig.component;\n resolver = resolver || this.resolver;\n var factory = resolver.resolveComponentFactory(component);\n var childContexts = this.parentContexts.getOrCreateContext(this.name).children;\n var injector = new OutletInjector(activatedRoute, childContexts, this.location.injector);\n this.activated = this.location.createComponent(factory, this.location.length, injector);\n // Calling `markForCheck` to make sure we will run the change detection when the\n // `RouterOutlet` is inside a `ChangeDetectionStrategy.OnPush` component.\n this.changeDetector.markForCheck();\n this.activateEvents.emit(this.activated.instance);\n };\n RouterOutlet.decorators = [\n { type: Directive, args: [{ selector: 'router-outlet', exportAs: 'outlet' },] }\n ];\n /** @nocollapse */\n RouterOutlet.ctorParameters = function () { return [\n { type: ChildrenOutletContexts },\n { type: ViewContainerRef },\n { type: ComponentFactoryResolver },\n { type: String, decorators: [{ type: Attribute, args: ['name',] }] },\n { type: ChangeDetectorRef }\n ]; };\n RouterOutlet.propDecorators = {\n activateEvents: [{ type: Output, args: ['activate',] }],\n deactivateEvents: [{ type: Output, args: ['deactivate',] }]\n };\n return RouterOutlet;\n}());\nvar OutletInjector = /** @class */ (function () {\n function OutletInjector(route, childContexts, parent) {\n this.route = route;\n this.childContexts = childContexts;\n this.parent = parent;\n }\n OutletInjector.prototype.get = function (token, notFoundValue) {\n if (token === ActivatedRoute) {\n return this.route;\n }\n if (token === ChildrenOutletContexts) {\n return this.childContexts;\n }\n return this.parent.get(token, notFoundValue);\n };\n return OutletInjector;\n}());\n\n/**\n*@license\n*Copyright Google Inc. All Rights Reserved.\n*\n*Use of this source code is governed by an MIT-style license that can be\n*found in the LICENSE file at https://angular.io/license\n*/\n/**\n * @description\n *\n * Provides a preloading strategy.\n *\n * @experimental\n */\nvar PreloadingStrategy = /** @class */ (function () {\n function PreloadingStrategy() {\n }\n return PreloadingStrategy;\n}());\n/**\n * @description\n *\n * Provides a preloading strategy that preloads all modules as quickly as possible.\n *\n * ```\n * RouteModule.forRoot(ROUTES, {preloadingStrategy: PreloadAllModules})\n * ```\n *\n * @experimental\n */\nvar PreloadAllModules = /** @class */ (function () {\n function PreloadAllModules() {\n }\n PreloadAllModules.prototype.preload = function (route, fn) {\n return fn().pipe(catchError(function () { return of(null); }));\n };\n return PreloadAllModules;\n}());\n/**\n * @description\n *\n * Provides a preloading strategy that does not preload any modules.\n *\n * This strategy is enabled by default.\n *\n * @experimental\n */\nvar NoPreloading = /** @class */ (function () {\n function NoPreloading() {\n }\n NoPreloading.prototype.preload = function (route, fn) { return of(null); };\n return NoPreloading;\n}());\n/**\n * The preloader optimistically loads all router configurations to\n * make navigations into lazily-loaded sections of the application faster.\n *\n * The preloader runs in the background. When the router bootstraps, the preloader\n * starts listening to all navigation events. After every such event, the preloader\n * will check if any configurations can be loaded lazily.\n *\n * If a route is protected by `canLoad` guards, the preloaded will not load it.\n *\n *\n */\nvar RouterPreloader = /** @class */ (function () {\n function RouterPreloader(router, moduleLoader, compiler, injector, preloadingStrategy) {\n this.router = router;\n this.injector = injector;\n this.preloadingStrategy = preloadingStrategy;\n var onStartLoad = function (r) { return router.triggerEvent(new RouteConfigLoadStart(r)); };\n var onEndLoad = function (r) { return router.triggerEvent(new RouteConfigLoadEnd(r)); };\n this.loader = new RouterConfigLoader(moduleLoader, compiler, onStartLoad, onEndLoad);\n }\n RouterPreloader.prototype.setUpPreloading = function () {\n var _this = this;\n this.subscription =\n this.router.events\n .pipe(filter(function (e) { return e instanceof NavigationEnd; }), concatMap(function () { return _this.preload(); }))\n .subscribe(function () { });\n };\n RouterPreloader.prototype.preload = function () {\n var ngModule = this.injector.get(NgModuleRef);\n return this.processRoutes(ngModule, this.router.config);\n };\n // TODO(jasonaden): This class relies on code external to the class to call setUpPreloading. If\n // this hasn't been done, ngOnDestroy will fail as this.subscription will be undefined. This\n // should be refactored.\n RouterPreloader.prototype.ngOnDestroy = function () { this.subscription.unsubscribe(); };\n RouterPreloader.prototype.processRoutes = function (ngModule, routes) {\n var e_1, _a;\n var res = [];\n try {\n for (var routes_1 = __values(routes), routes_1_1 = routes_1.next(); !routes_1_1.done; routes_1_1 = routes_1.next()) {\n var route = routes_1_1.value;\n // we already have the config loaded, just recurse\n if (route.loadChildren && !route.canLoad && route._loadedConfig) {\n var childConfig = route._loadedConfig;\n res.push(this.processRoutes(childConfig.module, childConfig.routes));\n // no config loaded, fetch the config\n }\n else if (route.loadChildren && !route.canLoad) {\n res.push(this.preloadConfig(ngModule, route));\n // recurse into children\n }\n else if (route.children) {\n res.push(this.processRoutes(ngModule, route.children));\n }\n }\n }\n catch (e_1_1) { e_1 = { error: e_1_1 }; }\n finally {\n try {\n if (routes_1_1 && !routes_1_1.done && (_a = routes_1.return)) _a.call(routes_1);\n }\n finally { if (e_1) throw e_1.error; }\n }\n return from(res).pipe(mergeAll(), map(function (_) { return void 0; }));\n };\n RouterPreloader.prototype.preloadConfig = function (ngModule, route) {\n var _this = this;\n return this.preloadingStrategy.preload(route, function () {\n var loaded$ = _this.loader.load(ngModule.injector, route);\n return loaded$.pipe(mergeMap(function (config) {\n route._loadedConfig = config;\n return _this.processRoutes(config.module, config.routes);\n }));\n });\n };\n RouterPreloader.decorators = [\n { type: Injectable }\n ];\n /** @nocollapse */\n RouterPreloader.ctorParameters = function () { return [\n { type: Router },\n { type: NgModuleFactoryLoader },\n { type: Compiler },\n { type: Injector },\n { type: PreloadingStrategy }\n ]; };\n return RouterPreloader;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar RouterScroller = /** @class */ (function () {\n function RouterScroller(router, \n /** @docsNotRequired */ viewportScroller, options) {\n if (options === void 0) { options = {}; }\n this.router = router;\n this.viewportScroller = viewportScroller;\n this.options = options;\n this.lastId = 0;\n this.lastSource = 'imperative';\n this.restoredId = 0;\n this.store = {};\n // Default both options to 'disabled'\n options.scrollPositionRestoration = options.scrollPositionRestoration || 'disabled';\n options.anchorScrolling = options.anchorScrolling || 'disabled';\n }\n RouterScroller.prototype.init = function () {\n // we want to disable the automatic scrolling because having two places\n // responsible for scrolling results race conditions, especially given\n // that browser don't implement this behavior consistently\n if (this.options.scrollPositionRestoration !== 'disabled') {\n this.viewportScroller.setHistoryScrollRestoration('manual');\n }\n this.routerEventsSubscription = this.createScrollEvents();\n this.scrollEventsSubscription = this.consumeScrollEvents();\n };\n RouterScroller.prototype.createScrollEvents = function () {\n var _this = this;\n return this.router.events.subscribe(function (e) {\n if (e instanceof NavigationStart) {\n // store the scroll position of the current stable navigations.\n _this.store[_this.lastId] = _this.viewportScroller.getScrollPosition();\n _this.lastSource = e.navigationTrigger;\n _this.restoredId = e.restoredState ? e.restoredState.navigationId : 0;\n }\n else if (e instanceof NavigationEnd) {\n _this.lastId = e.id;\n _this.scheduleScrollEvent(e, _this.router.parseUrl(e.urlAfterRedirects).fragment);\n }\n });\n };\n RouterScroller.prototype.consumeScrollEvents = function () {\n var _this = this;\n return this.router.events.subscribe(function (e) {\n if (!(e instanceof Scroll))\n return;\n // a popstate event. The pop state event will always ignore anchor scrolling.\n if (e.position) {\n if (_this.options.scrollPositionRestoration === 'top') {\n _this.viewportScroller.scrollToPosition([0, 0]);\n }\n else if (_this.options.scrollPositionRestoration === 'enabled') {\n _this.viewportScroller.scrollToPosition(e.position);\n }\n // imperative navigation \"forward\"\n }\n else {\n if (e.anchor && _this.options.anchorScrolling === 'enabled') {\n _this.viewportScroller.scrollToAnchor(e.anchor);\n }\n else if (_this.options.scrollPositionRestoration !== 'disabled') {\n _this.viewportScroller.scrollToPosition([0, 0]);\n }\n }\n });\n };\n RouterScroller.prototype.scheduleScrollEvent = function (routerEvent, anchor) {\n this.router.triggerEvent(new Scroll(routerEvent, this.lastSource === 'popstate' ? this.store[this.restoredId] : null, anchor));\n };\n RouterScroller.prototype.ngOnDestroy = function () {\n if (this.routerEventsSubscription) {\n this.routerEventsSubscription.unsubscribe();\n }\n if (this.scrollEventsSubscription) {\n this.scrollEventsSubscription.unsubscribe();\n }\n };\n return RouterScroller;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n *\n * Contains a list of directives\n *\n *\n */\nvar ROUTER_DIRECTIVES = [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive, EmptyOutletComponent];\n/**\n * @description\n *\n * Is used in DI to configure the router.\n *\n *\n */\nvar ROUTER_CONFIGURATION = new InjectionToken('ROUTER_CONFIGURATION');\n/**\n * @docsNotRequired\n */\nvar ROUTER_FORROOT_GUARD = new InjectionToken('ROUTER_FORROOT_GUARD');\nvar ROUTER_PROVIDERS = [\n Location,\n { provide: UrlSerializer, useClass: DefaultUrlSerializer },\n {\n provide: Router,\n useFactory: setupRouter,\n deps: [\n ApplicationRef, UrlSerializer, ChildrenOutletContexts, Location, Injector,\n NgModuleFactoryLoader, Compiler, ROUTES, ROUTER_CONFIGURATION,\n [UrlHandlingStrategy, new Optional()], [RouteReuseStrategy, new Optional()]\n ]\n },\n ChildrenOutletContexts,\n { provide: ActivatedRoute, useFactory: rootRoute, deps: [Router] },\n { provide: NgModuleFactoryLoader, useClass: SystemJsNgModuleLoader },\n RouterPreloader,\n NoPreloading,\n PreloadAllModules,\n { provide: ROUTER_CONFIGURATION, useValue: { enableTracing: false } },\n];\nfunction routerNgProbeToken() {\n return new NgProbeToken('Router', Router);\n}\n/**\n * @usageNotes\n *\n * RouterModule can be imported multiple times: once per lazily-loaded bundle.\n * Since the router deals with a global shared resource--location, we cannot have\n * more than one router service active.\n *\n * That is why there are two ways to create the module: `RouterModule.forRoot` and\n * `RouterModule.forChild`.\n *\n * * `forRoot` creates a module that contains all the directives, the given routes, and the router\n * service itself.\n * * `forChild` creates a module that contains all the directives and the given routes, but does not\n * include the router service.\n *\n * When registered at the root, the module should be used as follows\n *\n * ```\n * @NgModule({\n * imports: [RouterModule.forRoot(ROUTES)]\n * })\n * class MyNgModule {}\n * ```\n *\n * For submodules and lazy loaded submodules the module should be used as follows:\n *\n * ```\n * @NgModule({\n * imports: [RouterModule.forChild(ROUTES)]\n * })\n * class MyNgModule {}\n * ```\n *\n * @description\n *\n * Adds router directives and providers.\n *\n * Managing state transitions is one of the hardest parts of building applications. This is\n * especially true on the web, where you also need to ensure that the state is reflected in the URL.\n * In addition, we often want to split applications into multiple bundles and load them on demand.\n * Doing this transparently is not trivial.\n *\n * The Angular router solves these problems. Using the router, you can declaratively specify\n * application states, manage state transitions while taking care of the URL, and load bundles on\n * demand.\n *\n * [Read this developer guide](https://angular.io/docs/ts/latest/guide/router.html) to get an\n * overview of how the router should be used.\n *\n *\n */\nvar RouterModule = /** @class */ (function () {\n // Note: We are injecting the Router so it gets created eagerly...\n function RouterModule(guard, router) {\n }\n /**\n * Creates a module with all the router providers and directives. It also optionally sets up an\n * application listener to perform an initial navigation.\n *\n * Options (see `ExtraOptions`):\n * * `enableTracing` makes the router log all its internal events to the console.\n * * `useHash` enables the location strategy that uses the URL fragment instead of the history\n * API.\n * * `initialNavigation` disables the initial navigation.\n * * `errorHandler` provides a custom error handler.\n * * `preloadingStrategy` configures a preloading strategy (see `PreloadAllModules`).\n * * `onSameUrlNavigation` configures how the router handles navigation to the current URL. See\n * `ExtraOptions` for more details.\n * * `paramsInheritanceStrategy` defines how the router merges params, data and resolved data\n * from parent to child routes.\n */\n RouterModule.forRoot = function (routes, config) {\n return {\n ngModule: RouterModule,\n providers: [\n ROUTER_PROVIDERS,\n provideRoutes(routes),\n {\n provide: ROUTER_FORROOT_GUARD,\n useFactory: provideForRootGuard,\n deps: [[Router, new Optional(), new SkipSelf()]]\n },\n { provide: ROUTER_CONFIGURATION, useValue: config ? config : {} },\n {\n provide: LocationStrategy,\n useFactory: provideLocationStrategy,\n deps: [\n PlatformLocation, [new Inject(APP_BASE_HREF), new Optional()], ROUTER_CONFIGURATION\n ]\n },\n {\n provide: RouterScroller,\n useFactory: createRouterScroller,\n deps: [Router, ViewportScroller, ROUTER_CONFIGURATION]\n },\n {\n provide: PreloadingStrategy,\n useExisting: config && config.preloadingStrategy ? config.preloadingStrategy :\n NoPreloading\n },\n { provide: NgProbeToken, multi: true, useFactory: routerNgProbeToken },\n provideRouterInitializer(),\n ],\n };\n };\n /**\n * Creates a module with all the router directives and a provider registering routes.\n */\n RouterModule.forChild = function (routes) {\n return { ngModule: RouterModule, providers: [provideRoutes(routes)] };\n };\n RouterModule.decorators = [\n { type: NgModule, args: [{\n declarations: ROUTER_DIRECTIVES,\n exports: ROUTER_DIRECTIVES,\n entryComponents: [EmptyOutletComponent]\n },] }\n ];\n /** @nocollapse */\n RouterModule.ctorParameters = function () { return [\n { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [ROUTER_FORROOT_GUARD,] }] },\n { type: Router, decorators: [{ type: Optional }] }\n ]; };\n return RouterModule;\n}());\nfunction createRouterScroller(router, viewportScroller, config) {\n if (config.scrollOffset) {\n viewportScroller.setOffset(config.scrollOffset);\n }\n return new RouterScroller(router, viewportScroller, config);\n}\nfunction provideLocationStrategy(platformLocationStrategy, baseHref, options) {\n if (options === void 0) { options = {}; }\n return options.useHash ? new HashLocationStrategy(platformLocationStrategy, baseHref) :\n new PathLocationStrategy(platformLocationStrategy, baseHref);\n}\nfunction provideForRootGuard(router) {\n if (router) {\n throw new Error(\"RouterModule.forRoot() called twice. Lazy loaded modules should use RouterModule.forChild() instead.\");\n }\n return 'guarded';\n}\n/**\n * @description\n *\n * Registers routes.\n *\n * ### Example\n *\n * ```\n * @NgModule({\n * imports: [RouterModule.forChild(ROUTES)],\n * providers: [provideRoutes(EXTRA_ROUTES)]\n * })\n * class MyNgModule {}\n * ```\n *\n *\n */\nfunction provideRoutes(routes) {\n return [\n { provide: ANALYZE_FOR_ENTRY_COMPONENTS, multi: true, useValue: routes },\n { provide: ROUTES, multi: true, useValue: routes },\n ];\n}\nfunction setupRouter(ref, urlSerializer, contexts, location, injector, loader, compiler, config, opts, urlHandlingStrategy, routeReuseStrategy) {\n if (opts === void 0) { opts = {}; }\n var router = new Router(null, urlSerializer, contexts, location, injector, loader, compiler, flatten(config));\n if (urlHandlingStrategy) {\n router.urlHandlingStrategy = urlHandlingStrategy;\n }\n if (routeReuseStrategy) {\n router.routeReuseStrategy = routeReuseStrategy;\n }\n if (opts.errorHandler) {\n router.errorHandler = opts.errorHandler;\n }\n if (opts.malformedUriErrorHandler) {\n router.malformedUriErrorHandler = opts.malformedUriErrorHandler;\n }\n if (opts.enableTracing) {\n var dom_1 = ɵgetDOM();\n router.events.subscribe(function (e) {\n dom_1.logGroup(\"Router Event: \" + e.constructor.name);\n dom_1.log(e.toString());\n dom_1.log(e);\n dom_1.logGroupEnd();\n });\n }\n if (opts.onSameUrlNavigation) {\n router.onSameUrlNavigation = opts.onSameUrlNavigation;\n }\n if (opts.paramsInheritanceStrategy) {\n router.paramsInheritanceStrategy = opts.paramsInheritanceStrategy;\n }\n if (opts.urlUpdateStrategy) {\n router.urlUpdateStrategy = opts.urlUpdateStrategy;\n }\n if (opts.relativeLinkResolution) {\n router.relativeLinkResolution = opts.relativeLinkResolution;\n }\n return router;\n}\nfunction rootRoute(router) {\n return router.routerState.root;\n}\n/**\n * To initialize the router properly we need to do in two steps:\n *\n * We need to start the navigation in a APP_INITIALIZER to block the bootstrap if\n * a resolver or a guards executes asynchronously. Second, we need to actually run\n * activation in a BOOTSTRAP_LISTENER. We utilize the afterPreactivation\n * hook provided by the router to do that.\n *\n * The router navigation starts, reaches the point when preactivation is done, and then\n * pauses. It waits for the hook to be resolved. We then resolve it only in a bootstrap listener.\n */\nvar RouterInitializer = /** @class */ (function () {\n function RouterInitializer(injector) {\n this.injector = injector;\n this.initNavigation = false;\n this.resultOfPreactivationDone = new Subject();\n }\n RouterInitializer.prototype.appInitializer = function () {\n var _this = this;\n var p = this.injector.get(LOCATION_INITIALIZED, Promise.resolve(null));\n return p.then(function () {\n var resolve = null;\n var res = new Promise(function (r) { return resolve = r; });\n var router = _this.injector.get(Router);\n var opts = _this.injector.get(ROUTER_CONFIGURATION);\n if (_this.isLegacyDisabled(opts) || _this.isLegacyEnabled(opts)) {\n resolve(true);\n }\n else if (opts.initialNavigation === 'disabled') {\n router.setUpLocationChangeListener();\n resolve(true);\n }\n else if (opts.initialNavigation === 'enabled') {\n router.hooks.afterPreactivation = function () {\n // only the initial navigation should be delayed\n if (!_this.initNavigation) {\n _this.initNavigation = true;\n resolve(true);\n return _this.resultOfPreactivationDone;\n // subsequent navigations should not be delayed\n }\n else {\n return of(null);\n }\n };\n router.initialNavigation();\n }\n else {\n throw new Error(\"Invalid initialNavigation options: '\" + opts.initialNavigation + \"'\");\n }\n return res;\n });\n };\n RouterInitializer.prototype.bootstrapListener = function (bootstrappedComponentRef) {\n var opts = this.injector.get(ROUTER_CONFIGURATION);\n var preloader = this.injector.get(RouterPreloader);\n var routerScroller = this.injector.get(RouterScroller);\n var router = this.injector.get(Router);\n var ref = this.injector.get(ApplicationRef);\n if (bootstrappedComponentRef !== ref.components[0]) {\n return;\n }\n if (this.isLegacyEnabled(opts)) {\n router.initialNavigation();\n }\n else if (this.isLegacyDisabled(opts)) {\n router.setUpLocationChangeListener();\n }\n preloader.setUpPreloading();\n routerScroller.init();\n router.resetRootComponentType(ref.componentTypes[0]);\n this.resultOfPreactivationDone.next(null);\n this.resultOfPreactivationDone.complete();\n };\n RouterInitializer.prototype.isLegacyEnabled = function (opts) {\n return opts.initialNavigation === 'legacy_enabled' || opts.initialNavigation === true ||\n opts.initialNavigation === undefined;\n };\n RouterInitializer.prototype.isLegacyDisabled = function (opts) {\n return opts.initialNavigation === 'legacy_disabled' || opts.initialNavigation === false;\n };\n RouterInitializer.decorators = [\n { type: Injectable }\n ];\n /** @nocollapse */\n RouterInitializer.ctorParameters = function () { return [\n { type: Injector }\n ]; };\n return RouterInitializer;\n}());\nfunction getAppInitializer(r) {\n return r.appInitializer.bind(r);\n}\nfunction getBootstrapListener(r) {\n return r.bootstrapListener.bind(r);\n}\n/**\n * A token for the router initializer that will be called after the app is bootstrapped.\n *\n * @experimental\n */\nvar ROUTER_INITIALIZER = new InjectionToken('Router Initializer');\nfunction provideRouterInitializer() {\n return [\n RouterInitializer,\n {\n provide: APP_INITIALIZER,\n multi: true,\n useFactory: getAppInitializer,\n deps: [RouterInitializer]\n },\n { provide: ROUTER_INITIALIZER, useFactory: getBootstrapListener, deps: [RouterInitializer] },\n { provide: APP_BOOTSTRAP_LISTENER, multi: true, useExisting: ROUTER_INITIALIZER },\n ];\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar VERSION = new Version('6.1.7');\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// This file only reexports content of the `src` folder. Keep it that way.\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { ROUTER_FORROOT_GUARD as ɵangular_packages_router_router_a, RouterInitializer as ɵangular_packages_router_router_h, createRouterScroller as ɵangular_packages_router_router_c, getAppInitializer as ɵangular_packages_router_router_i, getBootstrapListener as ɵangular_packages_router_router_j, provideForRootGuard as ɵangular_packages_router_router_e, provideLocationStrategy as ɵangular_packages_router_router_d, provideRouterInitializer as ɵangular_packages_router_router_k, rootRoute as ɵangular_packages_router_router_g, routerNgProbeToken as ɵangular_packages_router_router_b, setupRouter as ɵangular_packages_router_router_f, RouterScroller as ɵangular_packages_router_router_n, Tree as ɵangular_packages_router_router_l, TreeNode as ɵangular_packages_router_router_m, RouterLink, RouterLinkWithHref, RouterLinkActive, RouterOutlet, ActivationEnd, ActivationStart, ChildActivationEnd, ChildActivationStart, GuardsCheckEnd, GuardsCheckStart, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, ResolveEnd, ResolveStart, RouteConfigLoadEnd, RouteConfigLoadStart, RouterEvent, RoutesRecognized, Scroll, RouteReuseStrategy, Router, ROUTES, ROUTER_CONFIGURATION, ROUTER_INITIALIZER, RouterModule, provideRoutes, ChildrenOutletContexts, OutletContext, NoPreloading, PreloadAllModules, PreloadingStrategy, RouterPreloader, ActivatedRoute, ActivatedRouteSnapshot, RouterState, RouterStateSnapshot, PRIMARY_OUTLET, convertToParamMap, UrlHandlingStrategy, DefaultUrlSerializer, UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree, VERSION, EmptyOutletComponent as ɵEmptyOutletComponent, ROUTER_PROVIDERS as ɵROUTER_PROVIDERS, flatten as ɵflatten };\n//# sourceMappingURL=router.js.map\n","\"use strict\";\n/**\n * @fileoverview This file was generated by the Angular template compiler. Do not edit.\n *\n * @suppress {suspiciousCode,uselessCode,missingProperties,missingOverride,checkTypes}\n * tslint:disable\n */ \nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar i0 = require(\"@angular/core\");\nvar i1 = require(\"./loading-indicator.component\");\nvar styles_LoadingIndicatorComponent = [];\nvar RenderType_LoadingIndicatorComponent = i0.ɵcrt({ encapsulation: 2, styles: styles_LoadingIndicatorComponent, data: {} });\nexports.RenderType_LoadingIndicatorComponent = RenderType_LoadingIndicatorComponent;\nfunction View_LoadingIndicatorComponent_0(_l) { return i0.ɵvid(0, [(_l()(), i0.ɵeld(0, 0, null, null, 3, \"div\", [[\"data-t-name\", \"LoadingIndicator\"]], [[8, \"className\", 0], [1, \"data-t-decorator\", 0]], null, null, null, null)), (_l()(), i0.ɵeld(1, 0, null, null, 0, \"div\", [[\"class\", \"a-loading-indicator__one\"]], null, null, null, null, null)), (_l()(), i0.ɵeld(2, 0, null, null, 0, \"div\", [[\"class\", \"a-loading-indicator__two\"]], null, null, null, null, null)), (_l()(), i0.ɵeld(3, 0, null, null, 0, \"div\", [[\"class\", \"a-loading-indicator__three\"]], null, null, null, null, null))], null, function (_ck, _v) { var _co = _v.component; var currVal_0 = i0.ɵinlineInterpolate(1, \"a-loading-indicator \", ((_co.modifier && (\"a-loading-indicator--\" + _co.modifier)) || _co.modifier), \"\"); var currVal_1 = _co.decorator; _ck(_v, 0, 0, currVal_0, currVal_1); }); }\nexports.View_LoadingIndicatorComponent_0 = View_LoadingIndicatorComponent_0;\nfunction View_LoadingIndicatorComponent_Host_0(_l) { return i0.ɵvid(0, [(_l()(), i0.ɵeld(0, 0, null, null, 1, \"cov-loading-indicator\", [], null, null, null, View_LoadingIndicatorComponent_0, RenderType_LoadingIndicatorComponent)), i0.ɵdid(1, 114688, null, 0, i1.LoadingIndicatorComponent, [i0.ElementRef], null, null)], function (_ck, _v) { _ck(_v, 1, 0); }, null); }\nexports.View_LoadingIndicatorComponent_Host_0 = View_LoadingIndicatorComponent_Host_0;\nvar LoadingIndicatorComponentNgFactory = i0.ɵccf(\"cov-loading-indicator\", i1.LoadingIndicatorComponent, View_LoadingIndicatorComponent_Host_0, { modifier: \"modifier\", decorator: \"decorator\" }, {}, []);\nexports.LoadingIndicatorComponentNgFactory = LoadingIndicatorComponentNgFactory;\n","
\\r\\n\"\r\n }] }\r\n ];\r\n ProductFilterPropertyComponent.propDecorators = {\r\n filterHeading: [{ type: Input }],\r\n filterGroups: [{ type: Input }],\r\n showFilterPopup: [{ type: Input }],\r\n pageSizeInitial: [{ type: Input }],\r\n pageSizeLoadMore: [{ type: Input }],\r\n loadMoreButtonText: [{ type: Input }],\r\n filterChanges: [{ type: Output }],\r\n onFilterOpenClicked: [{ type: Output }]\r\n };\r\n return ProductFilterPropertyComponent;\r\n}());\r\nexport { ProductFilterPropertyComponent };\r\n//# sourceMappingURL=product-filter-property.component.js.map","import * as tslib_1 from \"tslib\";\r\nimport { Component, ElementRef, Input, Renderer2, ViewChild } from '@angular/core';\r\nimport { TerrificOnInit } from '../../../helpers/angular-terrific-on-init/terrific-on-init';\r\nvar ProductCompareButtonComponent = /** @class */ (function (_super) {\r\n tslib_1.__extends(ProductCompareButtonComponent, _super);\r\n /**\r\n * ProductCompareButton abstraction\r\n * @param productCompareButtonRenderer\r\n * @type Renderer2\r\n * @description Renderer allows to manipulate the element without having to touch the DOM directly\r\n *\r\n */\r\n function ProductCompareButtonComponent(renderer) {\r\n var _this = _super.call(this, renderer) || this;\r\n _this.renderer = renderer;\r\n return _this;\r\n }\r\n ProductCompareButtonComponent.prototype.onTerrificBootstrap = function () {\r\n var productCompareButtonElement = this.productCompareButtonElementRef.nativeElement;\r\n this.renderer.setAttribute(productCompareButtonElement, 'data-t-name', 'ProductCompareButton');\r\n this.terrific.startNode(productCompareButtonElement);\r\n };\r\n /**\r\n * Implementation of Angular's OnDestroy lifecycle hook\r\n */\r\n ProductCompareButtonComponent.prototype.ngOnDestroy = function () {\r\n this.terrific.stopNode(this.productCompareButtonElementRef.nativeElement);\r\n };\r\n ProductCompareButtonComponent.decorators = [\r\n { type: Component, args: [{\r\n selector: 'cov-product-compare-button',\r\n template: \"
\\r\\n\\t\\r\\n
\\r\\n\"\r\n }] }\r\n ];\r\n /** @nocollapse */\r\n ProductCompareButtonComponent.ctorParameters = function () { return [\r\n { type: Renderer2 }\r\n ]; };\r\n ProductCompareButtonComponent.propDecorators = {\r\n productNumber: [{ type: Input }],\r\n productName: [{ type: Input }],\r\n market: [{ type: Input }],\r\n removeText: [{ type: Input }],\r\n addText: [{ type: Input }],\r\n productCompareButtonElementRef: [{ type: ViewChild, args: ['productCompareButton',] }]\r\n };\r\n return ProductCompareButtonComponent;\r\n}(TerrificOnInit));\r\nexport { ProductCompareButtonComponent };\r\n//# sourceMappingURL=product-compare-button.component.js.map","/**\n * @license Angular v6.1.7\n * (c) 2010-2018 Google, Inc. https://angular.io/\n * License: MIT\n */\n\nimport { __extends, __spread, __read } from 'tslib';\nimport { Injectable, InjectionToken, Inject, PLATFORM_ID, Injector, NgModule } from '@angular/core';\nimport { of, Observable } from 'rxjs';\nimport { concatMap, filter, map } from 'rxjs/operators';\nimport { DOCUMENT, ɵparseCookieValue } from '@angular/common';\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Transforms an `HttpRequest` into a stream of `HttpEvent`s, one of which will likely be a\n * `HttpResponse`.\n *\n * `HttpHandler` is injectable. When injected, the handler instance dispatches requests to the\n * first interceptor in the chain, which dispatches to the second, etc, eventually reaching the\n * `HttpBackend`.\n *\n * In an `HttpInterceptor`, the `HttpHandler` parameter is the next interceptor in the chain.\n *\n *\n */\nvar HttpHandler = /** @class */ (function () {\n function HttpHandler() {\n }\n return HttpHandler;\n}());\n/**\n * A final `HttpHandler` which will dispatch the request via browser HTTP APIs to a backend.\n *\n * Interceptors sit between the `HttpClient` interface and the `HttpBackend`.\n *\n * When injected, `HttpBackend` dispatches requests directly to the backend, without going\n * through the interceptor chain.\n *\n *\n */\nvar HttpBackend = /** @class */ (function () {\n function HttpBackend() {\n }\n return HttpBackend;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Immutable set of Http headers, with lazy parsing.\n *\n */\nvar HttpHeaders = /** @class */ (function () {\n function HttpHeaders(headers) {\n var _this = this;\n /**\n * Internal map of lowercased header names to the normalized\n * form of the name (the form seen first).\n */\n this.normalizedNames = new Map();\n /**\n * Queued updates to be materialized the next initialization.\n */\n this.lazyUpdate = null;\n if (!headers) {\n this.headers = new Map();\n }\n else if (typeof headers === 'string') {\n this.lazyInit = function () {\n _this.headers = new Map();\n headers.split('\\n').forEach(function (line) {\n var index = line.indexOf(':');\n if (index > 0) {\n var name_1 = line.slice(0, index);\n var key = name_1.toLowerCase();\n var value = line.slice(index + 1).trim();\n _this.maybeSetNormalizedName(name_1, key);\n if (_this.headers.has(key)) {\n _this.headers.get(key).push(value);\n }\n else {\n _this.headers.set(key, [value]);\n }\n }\n });\n };\n }\n else {\n this.lazyInit = function () {\n _this.headers = new Map();\n Object.keys(headers).forEach(function (name) {\n var values = headers[name];\n var key = name.toLowerCase();\n if (typeof values === 'string') {\n values = [values];\n }\n if (values.length > 0) {\n _this.headers.set(key, values);\n _this.maybeSetNormalizedName(name, key);\n }\n });\n };\n }\n }\n /**\n * Checks for existence of header by given name.\n */\n HttpHeaders.prototype.has = function (name) {\n this.init();\n return this.headers.has(name.toLowerCase());\n };\n /**\n * Returns first header that matches given name.\n */\n HttpHeaders.prototype.get = function (name) {\n this.init();\n var values = this.headers.get(name.toLowerCase());\n return values && values.length > 0 ? values[0] : null;\n };\n /**\n * Returns the names of the headers\n */\n HttpHeaders.prototype.keys = function () {\n this.init();\n return Array.from(this.normalizedNames.values());\n };\n /**\n * Returns list of header values for a given name.\n */\n HttpHeaders.prototype.getAll = function (name) {\n this.init();\n return this.headers.get(name.toLowerCase()) || null;\n };\n HttpHeaders.prototype.append = function (name, value) {\n return this.clone({ name: name, value: value, op: 'a' });\n };\n HttpHeaders.prototype.set = function (name, value) {\n return this.clone({ name: name, value: value, op: 's' });\n };\n HttpHeaders.prototype.delete = function (name, value) {\n return this.clone({ name: name, value: value, op: 'd' });\n };\n HttpHeaders.prototype.maybeSetNormalizedName = function (name, lcName) {\n if (!this.normalizedNames.has(lcName)) {\n this.normalizedNames.set(lcName, name);\n }\n };\n HttpHeaders.prototype.init = function () {\n var _this = this;\n if (!!this.lazyInit) {\n if (this.lazyInit instanceof HttpHeaders) {\n this.copyFrom(this.lazyInit);\n }\n else {\n this.lazyInit();\n }\n this.lazyInit = null;\n if (!!this.lazyUpdate) {\n this.lazyUpdate.forEach(function (update) { return _this.applyUpdate(update); });\n this.lazyUpdate = null;\n }\n }\n };\n HttpHeaders.prototype.copyFrom = function (other) {\n var _this = this;\n other.init();\n Array.from(other.headers.keys()).forEach(function (key) {\n _this.headers.set(key, other.headers.get(key));\n _this.normalizedNames.set(key, other.normalizedNames.get(key));\n });\n };\n HttpHeaders.prototype.clone = function (update) {\n var clone = new HttpHeaders();\n clone.lazyInit =\n (!!this.lazyInit && this.lazyInit instanceof HttpHeaders) ? this.lazyInit : this;\n clone.lazyUpdate = (this.lazyUpdate || []).concat([update]);\n return clone;\n };\n HttpHeaders.prototype.applyUpdate = function (update) {\n var key = update.name.toLowerCase();\n switch (update.op) {\n case 'a':\n case 's':\n var value = update.value;\n if (typeof value === 'string') {\n value = [value];\n }\n if (value.length === 0) {\n return;\n }\n this.maybeSetNormalizedName(update.name, key);\n var base = (update.op === 'a' ? this.headers.get(key) : undefined) || [];\n base.push.apply(base, __spread(value));\n this.headers.set(key, base);\n break;\n case 'd':\n var toDelete_1 = update.value;\n if (!toDelete_1) {\n this.headers.delete(key);\n this.normalizedNames.delete(key);\n }\n else {\n var existing = this.headers.get(key);\n if (!existing) {\n return;\n }\n existing = existing.filter(function (value) { return toDelete_1.indexOf(value) === -1; });\n if (existing.length === 0) {\n this.headers.delete(key);\n this.normalizedNames.delete(key);\n }\n else {\n this.headers.set(key, existing);\n }\n }\n break;\n }\n };\n /**\n * @internal\n */\n HttpHeaders.prototype.forEach = function (fn) {\n var _this = this;\n this.init();\n Array.from(this.normalizedNames.keys())\n .forEach(function (key) { return fn(_this.normalizedNames.get(key), _this.headers.get(key)); });\n };\n return HttpHeaders;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A `HttpParameterCodec` that uses `encodeURIComponent` and `decodeURIComponent` to\n * serialize and parse URL parameter keys and values.\n *\n *\n */\nvar HttpUrlEncodingCodec = /** @class */ (function () {\n function HttpUrlEncodingCodec() {\n }\n HttpUrlEncodingCodec.prototype.encodeKey = function (key) { return standardEncoding(key); };\n HttpUrlEncodingCodec.prototype.encodeValue = function (value) { return standardEncoding(value); };\n HttpUrlEncodingCodec.prototype.decodeKey = function (key) { return decodeURIComponent(key); };\n HttpUrlEncodingCodec.prototype.decodeValue = function (value) { return decodeURIComponent(value); };\n return HttpUrlEncodingCodec;\n}());\nfunction paramParser(rawParams, codec) {\n var map$$1 = new Map();\n if (rawParams.length > 0) {\n var params = rawParams.split('&');\n params.forEach(function (param) {\n var eqIdx = param.indexOf('=');\n var _a = __read(eqIdx == -1 ?\n [codec.decodeKey(param), ''] :\n [codec.decodeKey(param.slice(0, eqIdx)), codec.decodeValue(param.slice(eqIdx + 1))], 2), key = _a[0], val = _a[1];\n var list = map$$1.get(key) || [];\n list.push(val);\n map$$1.set(key, list);\n });\n }\n return map$$1;\n}\nfunction standardEncoding(v) {\n return encodeURIComponent(v)\n .replace(/%40/gi, '@')\n .replace(/%3A/gi, ':')\n .replace(/%24/gi, '$')\n .replace(/%2C/gi, ',')\n .replace(/%3B/gi, ';')\n .replace(/%2B/gi, '+')\n .replace(/%3D/gi, '=')\n .replace(/%3F/gi, '?')\n .replace(/%2F/gi, '/');\n}\n/**\n * An HTTP request/response body that represents serialized parameters,\n * per the MIME type `application/x-www-form-urlencoded`.\n *\n * This class is immutable - all mutation operations return a new instance.\n *\n *\n */\nvar HttpParams = /** @class */ (function () {\n function HttpParams(options) {\n if (options === void 0) { options = {}; }\n var _this = this;\n this.updates = null;\n this.cloneFrom = null;\n this.encoder = options.encoder || new HttpUrlEncodingCodec();\n if (!!options.fromString) {\n if (!!options.fromObject) {\n throw new Error(\"Cannot specify both fromString and fromObject.\");\n }\n this.map = paramParser(options.fromString, this.encoder);\n }\n else if (!!options.fromObject) {\n this.map = new Map();\n Object.keys(options.fromObject).forEach(function (key) {\n var value = options.fromObject[key];\n _this.map.set(key, Array.isArray(value) ? value : [value]);\n });\n }\n else {\n this.map = null;\n }\n }\n /**\n * Check whether the body has one or more values for the given parameter name.\n */\n HttpParams.prototype.has = function (param) {\n this.init();\n return this.map.has(param);\n };\n /**\n * Get the first value for the given parameter name, or `null` if it's not present.\n */\n HttpParams.prototype.get = function (param) {\n this.init();\n var res = this.map.get(param);\n return !!res ? res[0] : null;\n };\n /**\n * Get all values for the given parameter name, or `null` if it's not present.\n */\n HttpParams.prototype.getAll = function (param) {\n this.init();\n return this.map.get(param) || null;\n };\n /**\n * Get all the parameter names for this body.\n */\n HttpParams.prototype.keys = function () {\n this.init();\n return Array.from(this.map.keys());\n };\n /**\n * Construct a new body with an appended value for the given parameter name.\n */\n HttpParams.prototype.append = function (param, value) { return this.clone({ param: param, value: value, op: 'a' }); };\n /**\n * Construct a new body with a new value for the given parameter name.\n */\n HttpParams.prototype.set = function (param, value) { return this.clone({ param: param, value: value, op: 's' }); };\n /**\n * Construct a new body with either the given value for the given parameter\n * removed, if a value is given, or all values for the given parameter removed\n * if not.\n */\n HttpParams.prototype.delete = function (param, value) { return this.clone({ param: param, value: value, op: 'd' }); };\n /**\n * Serialize the body to an encoded string, where key-value pairs (separated by `=`) are\n * separated by `&`s.\n */\n HttpParams.prototype.toString = function () {\n var _this = this;\n this.init();\n return this.keys()\n .map(function (key) {\n var eKey = _this.encoder.encodeKey(key);\n return _this.map.get(key).map(function (value) { return eKey + '=' + _this.encoder.encodeValue(value); })\n .join('&');\n })\n .join('&');\n };\n HttpParams.prototype.clone = function (update) {\n var clone = new HttpParams({ encoder: this.encoder });\n clone.cloneFrom = this.cloneFrom || this;\n clone.updates = (this.updates || []).concat([update]);\n return clone;\n };\n HttpParams.prototype.init = function () {\n var _this = this;\n if (this.map === null) {\n this.map = new Map();\n }\n if (this.cloneFrom !== null) {\n this.cloneFrom.init();\n this.cloneFrom.keys().forEach(function (key) { return _this.map.set(key, _this.cloneFrom.map.get(key)); });\n this.updates.forEach(function (update) {\n switch (update.op) {\n case 'a':\n case 's':\n var base = (update.op === 'a' ? _this.map.get(update.param) : undefined) || [];\n base.push(update.value);\n _this.map.set(update.param, base);\n break;\n case 'd':\n if (update.value !== undefined) {\n var base_1 = _this.map.get(update.param) || [];\n var idx = base_1.indexOf(update.value);\n if (idx !== -1) {\n base_1.splice(idx, 1);\n }\n if (base_1.length > 0) {\n _this.map.set(update.param, base_1);\n }\n else {\n _this.map.delete(update.param);\n }\n }\n else {\n _this.map.delete(update.param);\n break;\n }\n }\n });\n this.cloneFrom = null;\n }\n };\n return HttpParams;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Determine whether the given HTTP method may include a body.\n */\nfunction mightHaveBody(method) {\n switch (method) {\n case 'DELETE':\n case 'GET':\n case 'HEAD':\n case 'OPTIONS':\n case 'JSONP':\n return false;\n default:\n return true;\n }\n}\n/**\n * Safely assert whether the given value is an ArrayBuffer.\n *\n * In some execution environments ArrayBuffer is not defined.\n */\nfunction isArrayBuffer(value) {\n return typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer;\n}\n/**\n * Safely assert whether the given value is a Blob.\n *\n * In some execution environments Blob is not defined.\n */\nfunction isBlob(value) {\n return typeof Blob !== 'undefined' && value instanceof Blob;\n}\n/**\n * Safely assert whether the given value is a FormData instance.\n *\n * In some execution environments FormData is not defined.\n */\nfunction isFormData(value) {\n return typeof FormData !== 'undefined' && value instanceof FormData;\n}\n/**\n * An outgoing HTTP request with an optional typed body.\n *\n * `HttpRequest` represents an outgoing request, including URL, method,\n * headers, body, and other request configuration options. Instances should be\n * assumed to be immutable. To modify a `HttpRequest`, the `clone`\n * method should be used.\n *\n *\n */\nvar HttpRequest = /** @class */ (function () {\n function HttpRequest(method, url, third, fourth) {\n this.url = url;\n /**\n * The request body, or `null` if one isn't set.\n *\n * Bodies are not enforced to be immutable, as they can include a reference to any\n * user-defined data type. However, interceptors should take care to preserve\n * idempotence by treating them as such.\n */\n this.body = null;\n /**\n * Whether this request should be made in a way that exposes progress events.\n *\n * Progress events are expensive (change detection runs on each event) and so\n * they should only be requested if the consumer intends to monitor them.\n */\n this.reportProgress = false;\n /**\n * Whether this request should be sent with outgoing credentials (cookies).\n */\n this.withCredentials = false;\n /**\n * The expected response type of the server.\n *\n * This is used to parse the response appropriately before returning it to\n * the requestee.\n */\n this.responseType = 'json';\n this.method = method.toUpperCase();\n // Next, need to figure out which argument holds the HttpRequestInit\n // options, if any.\n var options;\n // Check whether a body argument is expected. The only valid way to omit\n // the body argument is to use a known no-body method like GET.\n if (mightHaveBody(this.method) || !!fourth) {\n // Body is the third argument, options are the fourth.\n this.body = (third !== undefined) ? third : null;\n options = fourth;\n }\n else {\n // No body required, options are the third argument. The body stays null.\n options = third;\n }\n // If options have been passed, interpret them.\n if (options) {\n // Normalize reportProgress and withCredentials.\n this.reportProgress = !!options.reportProgress;\n this.withCredentials = !!options.withCredentials;\n // Override default response type of 'json' if one is provided.\n if (!!options.responseType) {\n this.responseType = options.responseType;\n }\n // Override headers if they're provided.\n if (!!options.headers) {\n this.headers = options.headers;\n }\n if (!!options.params) {\n this.params = options.params;\n }\n }\n // If no headers have been passed in, construct a new HttpHeaders instance.\n if (!this.headers) {\n this.headers = new HttpHeaders();\n }\n // If no parameters have been passed in, construct a new HttpUrlEncodedParams instance.\n if (!this.params) {\n this.params = new HttpParams();\n this.urlWithParams = url;\n }\n else {\n // Encode the parameters to a string in preparation for inclusion in the URL.\n var params = this.params.toString();\n if (params.length === 0) {\n // No parameters, the visible URL is just the URL given at creation time.\n this.urlWithParams = url;\n }\n else {\n // Does the URL already have query parameters? Look for '?'.\n var qIdx = url.indexOf('?');\n // There are 3 cases to handle:\n // 1) No existing parameters -> append '?' followed by params.\n // 2) '?' exists and is followed by existing query string ->\n // append '&' followed by params.\n // 3) '?' exists at the end of the url -> append params directly.\n // This basically amounts to determining the character, if any, with\n // which to join the URL and parameters.\n var sep = qIdx === -1 ? '?' : (qIdx < url.length - 1 ? '&' : '');\n this.urlWithParams = url + sep + params;\n }\n }\n }\n /**\n * Transform the free-form body into a serialized format suitable for\n * transmission to the server.\n */\n HttpRequest.prototype.serializeBody = function () {\n // If no body is present, no need to serialize it.\n if (this.body === null) {\n return null;\n }\n // Check whether the body is already in a serialized form. If so,\n // it can just be returned directly.\n if (isArrayBuffer(this.body) || isBlob(this.body) || isFormData(this.body) ||\n typeof this.body === 'string') {\n return this.body;\n }\n // Check whether the body is an instance of HttpUrlEncodedParams.\n if (this.body instanceof HttpParams) {\n return this.body.toString();\n }\n // Check whether the body is an object or array, and serialize with JSON if so.\n if (typeof this.body === 'object' || typeof this.body === 'boolean' ||\n Array.isArray(this.body)) {\n return JSON.stringify(this.body);\n }\n // Fall back on toString() for everything else.\n return this.body.toString();\n };\n /**\n * Examine the body and attempt to infer an appropriate MIME type\n * for it.\n *\n * If no such type can be inferred, this method will return `null`.\n */\n HttpRequest.prototype.detectContentTypeHeader = function () {\n // An empty body has no content type.\n if (this.body === null) {\n return null;\n }\n // FormData bodies rely on the browser's content type assignment.\n if (isFormData(this.body)) {\n return null;\n }\n // Blobs usually have their own content type. If it doesn't, then\n // no type can be inferred.\n if (isBlob(this.body)) {\n return this.body.type || null;\n }\n // Array buffers have unknown contents and thus no type can be inferred.\n if (isArrayBuffer(this.body)) {\n return null;\n }\n // Technically, strings could be a form of JSON data, but it's safe enough\n // to assume they're plain strings.\n if (typeof this.body === 'string') {\n return 'text/plain';\n }\n // `HttpUrlEncodedParams` has its own content-type.\n if (this.body instanceof HttpParams) {\n return 'application/x-www-form-urlencoded;charset=UTF-8';\n }\n // Arrays, objects, and numbers will be encoded as JSON.\n if (typeof this.body === 'object' || typeof this.body === 'number' ||\n Array.isArray(this.body)) {\n return 'application/json';\n }\n // No type could be inferred.\n return null;\n };\n HttpRequest.prototype.clone = function (update) {\n if (update === void 0) { update = {}; }\n // For method, url, and responseType, take the current value unless\n // it is overridden in the update hash.\n var method = update.method || this.method;\n var url = update.url || this.url;\n var responseType = update.responseType || this.responseType;\n // The body is somewhat special - a `null` value in update.body means\n // whatever current body is present is being overridden with an empty\n // body, whereas an `undefined` value in update.body implies no\n // override.\n var body = (update.body !== undefined) ? update.body : this.body;\n // Carefully handle the boolean options to differentiate between\n // `false` and `undefined` in the update args.\n var withCredentials = (update.withCredentials !== undefined) ? update.withCredentials : this.withCredentials;\n var reportProgress = (update.reportProgress !== undefined) ? update.reportProgress : this.reportProgress;\n // Headers and params may be appended to if `setHeaders` or\n // `setParams` are used.\n var headers = update.headers || this.headers;\n var params = update.params || this.params;\n // Check whether the caller has asked to add headers.\n if (update.setHeaders !== undefined) {\n // Set every requested header.\n headers =\n Object.keys(update.setHeaders)\n .reduce(function (headers, name) { return headers.set(name, update.setHeaders[name]); }, headers);\n }\n // Check whether the caller has asked to set params.\n if (update.setParams) {\n // Set every requested param.\n params = Object.keys(update.setParams)\n .reduce(function (params, param) { return params.set(param, update.setParams[param]); }, params);\n }\n // Finally, construct the new HttpRequest using the pieces from above.\n return new HttpRequest(method, url, body, {\n params: params, headers: headers, reportProgress: reportProgress, responseType: responseType, withCredentials: withCredentials,\n });\n };\n return HttpRequest;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Type enumeration for the different kinds of `HttpEvent`.\n *\n *\n */\nvar HttpEventType;\n(function (HttpEventType) {\n /**\n * The request was sent out over the wire.\n */\n HttpEventType[HttpEventType[\"Sent\"] = 0] = \"Sent\";\n /**\n * An upload progress event was received.\n */\n HttpEventType[HttpEventType[\"UploadProgress\"] = 1] = \"UploadProgress\";\n /**\n * The response status code and headers were received.\n */\n HttpEventType[HttpEventType[\"ResponseHeader\"] = 2] = \"ResponseHeader\";\n /**\n * A download progress event was received.\n */\n HttpEventType[HttpEventType[\"DownloadProgress\"] = 3] = \"DownloadProgress\";\n /**\n * The full response including the body was received.\n */\n HttpEventType[HttpEventType[\"Response\"] = 4] = \"Response\";\n /**\n * A custom event from an interceptor or a backend.\n */\n HttpEventType[HttpEventType[\"User\"] = 5] = \"User\";\n})(HttpEventType || (HttpEventType = {}));\n/**\n * Base class for both `HttpResponse` and `HttpHeaderResponse`.\n *\n *\n */\nvar HttpResponseBase = /** @class */ (function () {\n /**\n * Super-constructor for all responses.\n *\n * The single parameter accepted is an initialization hash. Any properties\n * of the response passed there will override the default values.\n */\n function HttpResponseBase(init, defaultStatus, defaultStatusText) {\n if (defaultStatus === void 0) { defaultStatus = 200; }\n if (defaultStatusText === void 0) { defaultStatusText = 'OK'; }\n // If the hash has values passed, use them to initialize the response.\n // Otherwise use the default values.\n this.headers = init.headers || new HttpHeaders();\n this.status = init.status !== undefined ? init.status : defaultStatus;\n this.statusText = init.statusText || defaultStatusText;\n this.url = init.url || null;\n // Cache the ok value to avoid defining a getter.\n this.ok = this.status >= 200 && this.status < 300;\n }\n return HttpResponseBase;\n}());\n/**\n * A partial HTTP response which only includes the status and header data,\n * but no response body.\n *\n * `HttpHeaderResponse` is a `HttpEvent` available on the response\n * event stream, only when progress events are requested.\n *\n *\n */\nvar HttpHeaderResponse = /** @class */ (function (_super) {\n __extends(HttpHeaderResponse, _super);\n /**\n * Create a new `HttpHeaderResponse` with the given parameters.\n */\n function HttpHeaderResponse(init) {\n if (init === void 0) { init = {}; }\n var _this = _super.call(this, init) || this;\n _this.type = HttpEventType.ResponseHeader;\n return _this;\n }\n /**\n * Copy this `HttpHeaderResponse`, overriding its contents with the\n * given parameter hash.\n */\n HttpHeaderResponse.prototype.clone = function (update) {\n if (update === void 0) { update = {}; }\n // Perform a straightforward initialization of the new HttpHeaderResponse,\n // overriding the current parameters with new ones if given.\n return new HttpHeaderResponse({\n headers: update.headers || this.headers,\n status: update.status !== undefined ? update.status : this.status,\n statusText: update.statusText || this.statusText,\n url: update.url || this.url || undefined,\n });\n };\n return HttpHeaderResponse;\n}(HttpResponseBase));\n/**\n * A full HTTP response, including a typed response body (which may be `null`\n * if one was not returned).\n *\n * `HttpResponse` is a `HttpEvent` available on the response event\n * stream.\n *\n *\n */\nvar HttpResponse = /** @class */ (function (_super) {\n __extends(HttpResponse, _super);\n /**\n * Construct a new `HttpResponse`.\n */\n function HttpResponse(init) {\n if (init === void 0) { init = {}; }\n var _this = _super.call(this, init) || this;\n _this.type = HttpEventType.Response;\n _this.body = init.body !== undefined ? init.body : null;\n return _this;\n }\n HttpResponse.prototype.clone = function (update) {\n if (update === void 0) { update = {}; }\n return new HttpResponse({\n body: (update.body !== undefined) ? update.body : this.body,\n headers: update.headers || this.headers,\n status: (update.status !== undefined) ? update.status : this.status,\n statusText: update.statusText || this.statusText,\n url: update.url || this.url || undefined,\n });\n };\n return HttpResponse;\n}(HttpResponseBase));\n/**\n * A response that represents an error or failure, either from a\n * non-successful HTTP status, an error while executing the request,\n * or some other failure which occurred during the parsing of the response.\n *\n * Any error returned on the `Observable` response stream will be\n * wrapped in an `HttpErrorResponse` to provide additional context about\n * the state of the HTTP layer when the error occurred. The error property\n * will contain either a wrapped Error object or the error response returned\n * from the server.\n *\n *\n */\nvar HttpErrorResponse = /** @class */ (function (_super) {\n __extends(HttpErrorResponse, _super);\n function HttpErrorResponse(init) {\n var _this = \n // Initialize with a default status of 0 / Unknown Error.\n _super.call(this, init, 0, 'Unknown Error') || this;\n _this.name = 'HttpErrorResponse';\n /**\n * Errors are never okay, even when the status code is in the 2xx success range.\n */\n _this.ok = false;\n // If the response was successful, then this was a parse error. Otherwise, it was\n // a protocol-level failure of some sort. Either the request failed in transit\n // or the server returned an unsuccessful status code.\n if (_this.status >= 200 && _this.status < 300) {\n _this.message = \"Http failure during parsing for \" + (init.url || '(unknown url)');\n }\n else {\n _this.message =\n \"Http failure response for \" + (init.url || '(unknown url)') + \": \" + init.status + \" \" + init.statusText;\n }\n _this.error = init.error || null;\n return _this;\n }\n return HttpErrorResponse;\n}(HttpResponseBase));\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Construct an instance of `HttpRequestOptions` from a source `HttpMethodOptions` and\n * the given `body`. Basically, this clones the object and adds the body.\n */\nfunction addBody(options, body) {\n return {\n body: body,\n headers: options.headers,\n observe: options.observe,\n params: options.params,\n reportProgress: options.reportProgress,\n responseType: options.responseType,\n withCredentials: options.withCredentials,\n };\n}\n/**\n * Perform HTTP requests.\n *\n * `HttpClient` is available as an injectable class, with methods to perform HTTP requests.\n * Each request method has multiple signatures, and the return type varies according to which\n * signature is called (mainly the values of `observe` and `responseType`).\n *\n *\n */\nvar HttpClient = /** @class */ (function () {\n function HttpClient(handler) {\n this.handler = handler;\n }\n /**\n * Constructs an `Observable` for a particular HTTP request that, when subscribed,\n * fires the request through the chain of registered interceptors and on to the\n * server.\n *\n * This method can be called in one of two ways. Either an `HttpRequest`\n * instance can be passed directly as the only parameter, or a method can be\n * passed as the first parameter, a string URL as the second, and an\n * options hash as the third.\n *\n * If a `HttpRequest` object is passed directly, an `Observable` of the\n * raw `HttpEvent` stream will be returned.\n *\n * If a request is instead built by providing a URL, the options object\n * determines the return type of `request()`. In addition to configuring\n * request parameters such as the outgoing headers and/or the body, the options\n * hash specifies two key pieces of information about the request: the\n * `responseType` and what to `observe`.\n *\n * The `responseType` value determines how a successful response body will be\n * parsed. If `responseType` is the default `json`, a type interface for the\n * resulting object may be passed as a type parameter to `request()`.\n *\n * The `observe` value determines the return type of `request()`, based on what\n * the consumer is interested in observing. A value of `events` will return an\n * `Observable` representing the raw `HttpEvent` stream,\n * including progress events by default. A value of `response` will return an\n * `Observable>` where the `T` parameter of `HttpResponse`\n * depends on the `responseType` and any optionally provided type parameter.\n * A value of `body` will return an `Observable` with the same `T` body type.\n */\n HttpClient.prototype.request = function (first, url, options) {\n var _this = this;\n if (options === void 0) { options = {}; }\n var req;\n // Firstly, check whether the primary argument is an instance of `HttpRequest`.\n if (first instanceof HttpRequest) {\n // It is. The other arguments must be undefined (per the signatures) and can be\n // ignored.\n req = first;\n }\n else {\n // It's a string, so it represents a URL. Construct a request based on it,\n // and incorporate the remaining arguments (assuming GET unless a method is\n // provided.\n // Figure out the headers.\n var headers = undefined;\n if (options.headers instanceof HttpHeaders) {\n headers = options.headers;\n }\n else {\n headers = new HttpHeaders(options.headers);\n }\n // Sort out parameters.\n var params = undefined;\n if (!!options.params) {\n if (options.params instanceof HttpParams) {\n params = options.params;\n }\n else {\n params = new HttpParams({ fromObject: options.params });\n }\n }\n // Construct the request.\n req = new HttpRequest(first, url, (options.body !== undefined ? options.body : null), {\n headers: headers,\n params: params,\n reportProgress: options.reportProgress,\n // By default, JSON is assumed to be returned for all calls.\n responseType: options.responseType || 'json',\n withCredentials: options.withCredentials,\n });\n }\n // Start with an Observable.of() the initial request, and run the handler (which\n // includes all interceptors) inside a concatMap(). This way, the handler runs\n // inside an Observable chain, which causes interceptors to be re-run on every\n // subscription (this also makes retries re-run the handler, including interceptors).\n var events$ = of(req).pipe(concatMap(function (req) { return _this.handler.handle(req); }));\n // If coming via the API signature which accepts a previously constructed HttpRequest,\n // the only option is to get the event stream. Otherwise, return the event stream if\n // that is what was requested.\n if (first instanceof HttpRequest || options.observe === 'events') {\n return events$;\n }\n // The requested stream contains either the full response or the body. In either\n // case, the first step is to filter the event stream to extract a stream of\n // responses(s).\n var res$ = events$.pipe(filter(function (event) { return event instanceof HttpResponse; }));\n // Decide which stream to return.\n switch (options.observe || 'body') {\n case 'body':\n // The requested stream is the body. Map the response stream to the response\n // body. This could be done more simply, but a misbehaving interceptor might\n // transform the response body into a different format and ignore the requested\n // responseType. Guard against this by validating that the response is of the\n // requested type.\n switch (req.responseType) {\n case 'arraybuffer':\n return res$.pipe(map(function (res) {\n // Validate that the body is an ArrayBuffer.\n if (res.body !== null && !(res.body instanceof ArrayBuffer)) {\n throw new Error('Response is not an ArrayBuffer.');\n }\n return res.body;\n }));\n case 'blob':\n return res$.pipe(map(function (res) {\n // Validate that the body is a Blob.\n if (res.body !== null && !(res.body instanceof Blob)) {\n throw new Error('Response is not a Blob.');\n }\n return res.body;\n }));\n case 'text':\n return res$.pipe(map(function (res) {\n // Validate that the body is a string.\n if (res.body !== null && typeof res.body !== 'string') {\n throw new Error('Response is not a string.');\n }\n return res.body;\n }));\n case 'json':\n default:\n // No validation needed for JSON responses, as they can be of any type.\n return res$.pipe(map(function (res) { return res.body; }));\n }\n case 'response':\n // The response stream was requested directly, so return it.\n return res$;\n default:\n // Guard against new future observe types being added.\n throw new Error(\"Unreachable: unhandled observe type \" + options.observe + \"}\");\n }\n };\n /**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * DELETE request to be executed on the server. See the individual overloads for\n * details of `delete()`'s return type based on the provided options.\n */\n HttpClient.prototype.delete = function (url, options) {\n if (options === void 0) { options = {}; }\n return this.request('DELETE', url, options);\n };\n /**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * GET request to be executed on the server. See the individual overloads for\n * details of `get()`'s return type based on the provided options.\n */\n HttpClient.prototype.get = function (url, options) {\n if (options === void 0) { options = {}; }\n return this.request('GET', url, options);\n };\n /**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * HEAD request to be executed on the server. See the individual overloads for\n * details of `head()`'s return type based on the provided options.\n */\n HttpClient.prototype.head = function (url, options) {\n if (options === void 0) { options = {}; }\n return this.request('HEAD', url, options);\n };\n /**\n * Constructs an `Observable` which, when subscribed, will cause a request\n * with the special method `JSONP` to be dispatched via the interceptor pipeline.\n *\n * A suitable interceptor must be installed (e.g. via the `HttpClientJsonpModule`).\n * If no such interceptor is reached, then the `JSONP` request will likely be\n * rejected by the configured backend.\n */\n HttpClient.prototype.jsonp = function (url, callbackParam) {\n return this.request('JSONP', url, {\n params: new HttpParams().append(callbackParam, 'JSONP_CALLBACK'),\n observe: 'body',\n responseType: 'json',\n });\n };\n /**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * OPTIONS request to be executed on the server. See the individual overloads for\n * details of `options()`'s return type based on the provided options.\n */\n HttpClient.prototype.options = function (url, options) {\n if (options === void 0) { options = {}; }\n return this.request('OPTIONS', url, options);\n };\n /**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * PATCH request to be executed on the server. See the individual overloads for\n * details of `patch()`'s return type based on the provided options.\n */\n HttpClient.prototype.patch = function (url, body, options) {\n if (options === void 0) { options = {}; }\n return this.request('PATCH', url, addBody(options, body));\n };\n /**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * POST request to be executed on the server. See the individual overloads for\n * details of `post()`'s return type based on the provided options.\n */\n HttpClient.prototype.post = function (url, body, options) {\n if (options === void 0) { options = {}; }\n return this.request('POST', url, addBody(options, body));\n };\n /**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * PUT request to be executed on the server. See the individual overloads for\n * details of `put()`'s return type based on the provided options.\n */\n HttpClient.prototype.put = function (url, body, options) {\n if (options === void 0) { options = {}; }\n return this.request('PUT', url, addBody(options, body));\n };\n HttpClient.decorators = [\n { type: Injectable }\n ];\n /** @nocollapse */\n HttpClient.ctorParameters = function () { return [\n { type: HttpHandler }\n ]; };\n return HttpClient;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * `HttpHandler` which applies an `HttpInterceptor` to an `HttpRequest`.\n *\n *\n */\nvar HttpInterceptorHandler = /** @class */ (function () {\n function HttpInterceptorHandler(next, interceptor) {\n this.next = next;\n this.interceptor = interceptor;\n }\n HttpInterceptorHandler.prototype.handle = function (req) {\n return this.interceptor.intercept(req, this.next);\n };\n return HttpInterceptorHandler;\n}());\n/**\n * A multi-provider token which represents the array of `HttpInterceptor`s that\n * are registered.\n *\n *\n */\nvar HTTP_INTERCEPTORS = new InjectionToken('HTTP_INTERCEPTORS');\nvar NoopInterceptor = /** @class */ (function () {\n function NoopInterceptor() {\n }\n NoopInterceptor.prototype.intercept = function (req, next) {\n return next.handle(req);\n };\n NoopInterceptor.decorators = [\n { type: Injectable }\n ];\n return NoopInterceptor;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Every request made through JSONP needs a callback name that's unique across the\n// whole page. Each request is assigned an id and the callback name is constructed\n// from that. The next id to be assigned is tracked in a global variable here that\n// is shared among all applications on the page.\nvar nextRequestId = 0;\n// Error text given when a JSONP script is injected, but doesn't invoke the callback\n// passed in its URL.\nvar JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';\n// Error text given when a request is passed to the JsonpClientBackend that doesn't\n// have a request method JSONP.\nvar JSONP_ERR_WRONG_METHOD = 'JSONP requests must use JSONP request method.';\nvar JSONP_ERR_WRONG_RESPONSE_TYPE = 'JSONP requests must use Json response type.';\n/**\n * DI token/abstract type representing a map of JSONP callbacks.\n *\n * In the browser, this should always be the `window` object.\n *\n *\n */\nvar JsonpCallbackContext = /** @class */ (function () {\n function JsonpCallbackContext() {\n }\n return JsonpCallbackContext;\n}());\n/**\n * `HttpBackend` that only processes `HttpRequest` with the JSONP method,\n * by performing JSONP style requests.\n *\n *\n */\nvar JsonpClientBackend = /** @class */ (function () {\n function JsonpClientBackend(callbackMap, document) {\n this.callbackMap = callbackMap;\n this.document = document;\n }\n /**\n * Get the name of the next callback method, by incrementing the global `nextRequestId`.\n */\n JsonpClientBackend.prototype.nextCallback = function () { return \"ng_jsonp_callback_\" + nextRequestId++; };\n /**\n * Process a JSONP request and return an event stream of the results.\n */\n JsonpClientBackend.prototype.handle = function (req) {\n var _this = this;\n // Firstly, check both the method and response type. If either doesn't match\n // then the request was improperly routed here and cannot be handled.\n if (req.method !== 'JSONP') {\n throw new Error(JSONP_ERR_WRONG_METHOD);\n }\n else if (req.responseType !== 'json') {\n throw new Error(JSONP_ERR_WRONG_RESPONSE_TYPE);\n }\n // Everything else happens inside the Observable boundary.\n return new Observable(function (observer) {\n // The first step to make a request is to generate the callback name, and replace the\n // callback placeholder in the URL with the name. Care has to be taken here to ensure\n // a trailing &, if matched, gets inserted back into the URL in the correct place.\n var callback = _this.nextCallback();\n var url = req.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/, \"=\" + callback + \"$1\");\n // Construct the