{"version":3,"file":"router.umd.min.js","sources":["../../../../packages/router/src/router_module.ts","../../../../packages/router/src/router_outlet_context.ts","../../../../packages/router/src/directives/router_outlet.ts","../../../../packages/router/src/router_preloader.ts","../../../../packages/router/src/directives/router_link_active.ts","../../../../packages/router/src/directives/router_link.ts","../../../../packages/router/src/recognize.ts","../../../../packages/router/src/route_reuse_strategy.ts","../../../../packages/router/src/router_config_loader.ts","../../../../packages/router/src/url_handling_strategy.ts","../../../../packages/router/src/router.ts","../../../../packages/router/src/version.ts","../../../../node_modules/tslib/tslib.es6.js","../../../../packages/router/src/events.ts","../../../../packages/router/src/shared.ts","../../../../packages/router/src/config.ts","../../../../packages/router/src/url_tree.ts","../../../../packages/router/src/apply_redirects.ts","../../../../packages/router/src/router_state.ts","../../../../packages/router/src/create_url_tree.ts","../../../../packages/router/src/create_router_state.ts","../../../../packages/router/src/utils/tree.ts","../../../../packages/router/src/utils/collection.ts"],"sourcesContent":["/**\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\nimport {APP_BASE_HREF, HashLocationStrategy, LOCATION_INITIALIZED, Location, LocationStrategy, PathLocationStrategy, PlatformLocation} from '@angular/common';\nimport {ANALYZE_FOR_ENTRY_COMPONENTS, APP_BOOTSTRAP_LISTENER, APP_INITIALIZER, ApplicationRef, Compiler, ComponentRef, Inject, Injectable, InjectionToken, Injector, ModuleWithProviders, NgModule, NgModuleFactoryLoader, NgProbeToken, Optional, Provider, SkipSelf, SystemJsNgModuleLoader} from '@angular/core';\nimport {ɵgetDOM as getDOM} from '@angular/platform-browser';\nimport {Subject} from 'rxjs/Subject';\nimport {of } from 'rxjs/observable/of';\n\nimport {Route, Routes} from './config';\nimport {RouterLink, RouterLinkWithHref} from './directives/router_link';\nimport {RouterLinkActive} from './directives/router_link_active';\nimport {RouterOutlet} from './directives/router_outlet';\nimport {RouteReuseStrategy} from './route_reuse_strategy';\nimport {ErrorHandler, Router} from './router';\nimport {ROUTES} from './router_config_loader';\nimport {ChildrenOutletContexts} from './router_outlet_context';\nimport {NoPreloading, PreloadAllModules, PreloadingStrategy, RouterPreloader} from './router_preloader';\nimport {ActivatedRoute} from './router_state';\nimport {UrlHandlingStrategy} from './url_handling_strategy';\nimport {DefaultUrlSerializer, UrlSerializer} from './url_tree';\nimport {flatten} from './utils/collection';\n/**\n * \\@whatItDoes Contains a list of directives\n * \\@stable\n */\nconst ROUTER_DIRECTIVES = [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive];\n/**\n * \\@whatItDoes Is used in DI to configure the router.\n * \\@stable\n */\nexport const ROUTER_CONFIGURATION = new InjectionToken<ExtraOptions>('ROUTER_CONFIGURATION');\n/**\n * \\@docsNotRequired\n */\nexport const ROUTER_FORROOT_GUARD = new InjectionToken<void>('ROUTER_FORROOT_GUARD');\n\nexport const /** @type {?} */ ROUTER_PROVIDERS: Provider[] = [\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];\n/**\n * @return {?}\n */\nexport function routerNgProbeToken() {\n  return new NgProbeToken('Router', Router);\n}\n/**\n * \\@whatItDoes Adds router directives and providers.\n * \n * \\@howToUse \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 * 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 * \\@stable\n */\nexport class RouterModule {\n/**\n * @param {?} guard\n * @param {?} router\n */\nconstructor(  guard: any,  router: Router) {}\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:\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 * @param {?} routes\n * @param {?=} config\n * @return {?}\n */\nstatic forRoot(routes: Routes, config?: ExtraOptions): ModuleWithProviders {\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: 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 * @param {?} routes\n * @return {?}\n */\nstatic forChild(routes: Routes): ModuleWithProviders {\n    return {ngModule: RouterModule, providers: [provideRoutes(routes)]};\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: NgModule, args: [{declarations: ROUTER_DIRECTIVES, exports: ROUTER_DIRECTIVES}, ] },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [ROUTER_FORROOT_GUARD, ] }, ]},\n{type: Router, decorators: [{ type: Optional }, ]},\n];\n}\n\nfunction RouterModule_tsickle_Closure_declarations() {\n/** @type {?} */\nRouterModule.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nRouterModule.ctorParameters;\n}\n\n/**\n * @param {?} platformLocationStrategy\n * @param {?} baseHref\n * @param {?=} options\n * @return {?}\n */\nexport function provideLocationStrategy(\n    platformLocationStrategy: PlatformLocation, baseHref: string, options: ExtraOptions = {}) {\n  return options.useHash ? new HashLocationStrategy(platformLocationStrategy, baseHref) :\n                           new PathLocationStrategy(platformLocationStrategy, baseHref);\n}\n/**\n * @param {?} router\n * @return {?}\n */\nexport function provideForRootGuard(router: Router): any {\n  if (router) {\n    throw new Error(\n        `RouterModule.forRoot() called twice. Lazy loaded modules should use RouterModule.forChild() instead.`);\n  }\n  return 'guarded';\n}\n/**\n * \\@whatItDoes Registers routes.\n * \n * \\@howToUse \n * \n * ```\n * \\@NgModule({ \n *   imports: [RouterModule.forChild(ROUTES)],\n *   providers: [provideRoutes(EXTRA_ROUTES)]\n * })\n * class MyNgModule {}\n * ```\n * \n * \\@stable\n * @param {?} routes\n * @return {?}\n */\nexport function provideRoutes(routes: Routes): any {\n  return [\n    {provide: ANALYZE_FOR_ENTRY_COMPONENTS, multi: true, useValue: routes},\n    {provide: ROUTES, multi: true, useValue: routes},\n  ];\n}\n\n/**\n * @whatItDoes Represents an option to configure when the initial navigation is performed.\n *\n * @description\n * * 'enabled' - the initial navigation starts before the root component is created.\n * The bootstrap is blocked until the initial navigation is complete.\n * * 'disabled' - the initial navigation is not performed. The location listener is set up before\n * the root component gets created.\n * * 'legacy_enabled'- the initial navigation starts after the root component has been created.\n * The bootstrap is not blocked until the initial navigation is complete. @deprecated\n * * 'legacy_disabled'- the initial navigation is not performed. The location listener is set up\n * after @deprecated\n * the root component gets created.\n * * `true` - same as 'legacy_enabled'. @deprecated since v4\n * * `false` - same as 'legacy_disabled'. @deprecated since v4\n *\n * The 'enabled' option should be used for applications unless there is a reason to have\n * more control over when the router starts its initial navigation due to some complex\n * initialization logic. In this case, 'disabled' should be used.\n *\n * The 'legacy_enabled' and 'legacy_disabled' should not be used for new applications.\n *\n * @experimental\n */\nexport type InitialNavigation =\n    true | false | 'enabled' | 'disabled' | 'legacy_enabled' | 'legacy_disabled';\n\n/**\n * @whatItDoes Represents options to configure the router.\n *\n * @stable\n */\nexport interface ExtraOptions {\n  /**\n   * Makes the router log all its internal events to the console.\n   */\n  enableTracing?: boolean;\n\n  /**\n   * Enables the location strategy that uses the URL fragment instead of the history API.\n   */\n  useHash?: boolean;\n\n  /**\n   * Disables the initial navigation.\n   */\n  initialNavigation?: InitialNavigation;\n\n  /**\n   * A custom error handler.\n   */\n  errorHandler?: ErrorHandler;\n\n  /**\n   * Configures a preloading strategy. See {@link PreloadAllModules}.\n   */\n  preloadingStrategy?: any;\n}\n/**\n * @param {?} ref\n * @param {?} urlSerializer\n * @param {?} contexts\n * @param {?} location\n * @param {?} injector\n * @param {?} loader\n * @param {?} compiler\n * @param {?} config\n * @param {?=} opts\n * @param {?=} urlHandlingStrategy\n * @param {?=} routeReuseStrategy\n * @return {?}\n */\nexport function setupRouter(\n    ref: ApplicationRef, urlSerializer: UrlSerializer, contexts: ChildrenOutletContexts,\n    location: Location, injector: Injector, loader: NgModuleFactoryLoader, compiler: Compiler,\n    config: Route[][], opts: ExtraOptions = {}, urlHandlingStrategy?: UrlHandlingStrategy,\n    routeReuseStrategy?: RouteReuseStrategy) {\n  const /** @type {?} */ router = new Router(\n      null, urlSerializer, contexts, location, injector, loader, compiler, flatten(config));\n\n  if (urlHandlingStrategy) {\n    router.urlHandlingStrategy = urlHandlingStrategy;\n  }\n\n  if (routeReuseStrategy) {\n    router.routeReuseStrategy = routeReuseStrategy;\n  }\n\n  if (opts.errorHandler) {\n    router.errorHandler = opts.errorHandler;\n  }\n\n  if (opts.enableTracing) {\n    const /** @type {?} */ dom = getDOM();\n    router.events.subscribe(e => {\n      dom.logGroup(`Router Event: ${( /** @type {?} */((<any>e.constructor))).name}`);\n      dom.log(e.toString());\n      dom.log(e);\n      dom.logGroupEnd();\n    });\n  }\n\n  return router;\n}\n/**\n * @param {?} router\n * @return {?}\n */\nexport function rootRoute(router: Router): ActivatedRoute {\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 */\nexport class RouterInitializer {\nprivate initNavigation: boolean = false;\nprivate resultOfPreactivationDone = new Subject<void>();\n/**\n * @param {?} injector\n */\nconstructor(private injector: Injector) {}\n/**\n * @return {?}\n */\nappInitializer(): Promise<any> {\n    const /** @type {?} */ p: Promise<any> = this.injector.get(LOCATION_INITIALIZED, Promise.resolve(null));\n    return p.then(() => {\n      let /** @type {?} */ resolve: Function = /** @type {?} */(( null));\n      const /** @type {?} */ res = new Promise(r => resolve = r);\n      const /** @type {?} */ router = this.injector.get(Router);\n      const /** @type {?} */ opts = this.injector.get(ROUTER_CONFIGURATION);\n\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 = () => {\n          // only the initial navigation should be delayed\n          if (!this.initNavigation) {\n            this.initNavigation = true;\n            resolve(true);\n            return this.resultOfPreactivationDone;\n\n            // subsequent navigations should not be delayed\n          } else {\n            return /** @type {?} */(( of (null) as any));\n          }\n        };\n        router.initialNavigation();\n\n      } else {\n        throw new Error(`Invalid initialNavigation options: '${opts.initialNavigation}'`);\n      }\n\n      return res;\n    });\n  }\n/**\n * @param {?} bootstrappedComponentRef\n * @return {?}\n */\nbootstrapListener(bootstrappedComponentRef: ComponentRef<any>): void {\n    const /** @type {?} */ opts = this.injector.get(ROUTER_CONFIGURATION);\n    const /** @type {?} */ preloader = this.injector.get(RouterPreloader);\n    const /** @type {?} */ router = this.injector.get(Router);\n    const /** @type {?} */ ref = this.injector.get(ApplicationRef);\n\n    if (bootstrappedComponentRef !== ref.components[0]) {\n      return;\n    }\n\n    if (this.isLegacyEnabled(opts)) {\n      router.initialNavigation();\n    } else if (this.isLegacyDisabled(opts)) {\n      router.setUpLocationChangeListener();\n    }\n\n    preloader.setUpPreloading();\n    router.resetRootComponentType(ref.componentTypes[0]);\n    this.resultOfPreactivationDone.next( /** @type {?} */((null)));\n    this.resultOfPreactivationDone.complete();\n  }\n/**\n * @param {?} opts\n * @return {?}\n */\nprivate isLegacyEnabled(opts: ExtraOptions): boolean {\n    return opts.initialNavigation === 'legacy_enabled' || opts.initialNavigation === true ||\n        opts.initialNavigation === undefined;\n  }\n/**\n * @param {?} opts\n * @return {?}\n */\nprivate isLegacyDisabled(opts: ExtraOptions): boolean {\n    return opts.initialNavigation === 'legacy_disabled' || opts.initialNavigation === false;\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: Injector, },\n];\n}\n\nfunction RouterInitializer_tsickle_Closure_declarations() {\n/** @type {?} */\nRouterInitializer.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nRouterInitializer.ctorParameters;\n/** @type {?} */\nRouterInitializer.prototype.initNavigation;\n/** @type {?} */\nRouterInitializer.prototype.resultOfPreactivationDone;\n/** @type {?} */\nRouterInitializer.prototype.injector;\n}\n\n/**\n * @param {?} r\n * @return {?}\n */\nexport function getAppInitializer(r: RouterInitializer) {\n  return r.appInitializer.bind(r);\n}\n/**\n * @param {?} r\n * @return {?}\n */\nexport function getBootstrapListener(r: RouterInitializer) {\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 */\nexport const ROUTER_INITIALIZER =\n    new InjectionToken<(compRef: ComponentRef<any>) => void>('Router Initializer');\n/**\n * @return {?}\n */\nexport function 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\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\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\nimport {ComponentFactoryResolver, ComponentRef} from '@angular/core';\n\nimport {RouterOutlet} from './directives/router_outlet';\nimport {ActivatedRoute} from './router_state';\n/**\n * Store contextual information about a {\\@link RouterOutlet}\n * \n * \\@stable\n */\nexport class OutletContext {\n  outlet: RouterOutlet|null = null;\n  route: ActivatedRoute|null = null;\n  resolver: ComponentFactoryResolver|null = null;\n  children = new ChildrenOutletContexts();\n  attachRef: ComponentRef<any>|null = null;\n}\n\nfunction OutletContext_tsickle_Closure_declarations() {\n/** @type {?} */\nOutletContext.prototype.outlet;\n/** @type {?} */\nOutletContext.prototype.route;\n/** @type {?} */\nOutletContext.prototype.resolver;\n/** @type {?} */\nOutletContext.prototype.children;\n/** @type {?} */\nOutletContext.prototype.attachRef;\n}\n\n/**\n * Store contextual information about the children (= nested) {\\@link RouterOutlet}\n * \n * \\@stable\n */\nexport class ChildrenOutletContexts {\nprivate contexts = new Map<string, OutletContext>();\n/**\n * Called when a `RouterOutlet` directive is instantiated\n * @param {?} childName\n * @param {?} outlet\n * @return {?}\n */\nonChildOutletCreated(childName: string, outlet: RouterOutlet): void {\n    const /** @type {?} */ 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 * @param {?} childName\n * @return {?}\n */\nonChildOutletDestroyed(childName: string): void {\n    const /** @type {?} */ 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 * @return {?}\n */\nonOutletDeactivated(): Map<string, OutletContext> {\n    const /** @type {?} */ contexts = this.contexts;\n    this.contexts = new Map();\n    return contexts;\n  }\n/**\n * @param {?} contexts\n * @return {?}\n */\nonOutletReAttached(contexts: Map<string, OutletContext>) { this.contexts = contexts; }\n/**\n * @param {?} childName\n * @return {?}\n */\ngetOrCreateContext(childName: string): OutletContext {\n    let /** @type {?} */ context = this.getContext(childName);\n\n    if (!context) {\n      context = new OutletContext();\n      this.contexts.set(childName, context);\n    }\n\n    return context;\n  }\n/**\n * @param {?} childName\n * @return {?}\n */\ngetContext(childName: string): OutletContext|null { return this.contexts.get(childName) || null; }\n}\n\nfunction ChildrenOutletContexts_tsickle_Closure_declarations() {\n/** @type {?} */\nChildrenOutletContexts.prototype.contexts;\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\nimport {Attribute, ChangeDetectorRef, ComponentFactoryResolver, ComponentRef, Directive, EventEmitter, Injector, OnDestroy, OnInit, Output, ViewContainerRef} from '@angular/core';\n\nimport {ChildrenOutletContexts} from '../router_outlet_context';\nimport {ActivatedRoute} from '../router_state';\nimport {PRIMARY_OUTLET} from '../shared';\n/**\n * \\@whatItDoes Acts as a placeholder that Angular dynamically fills based on the current router\n * state.\n * \n * \\@howToUse \n * \n * ```\n * <router-outlet></router-outlet>\n * <router-outlet name='left'></router-outlet>\n * <router-outlet name='right'></router-outlet>\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 * <router-outlet\n *   (activate)='onActivate($event)'\n *   (deactivate)='onDeactivate($event)'></router-outlet>\n * ```\n * \\@ngModule RouterModule\n * \n * \\@stable\n */\nexport class RouterOutlet implements OnDestroy, OnInit {\nprivate activated: ComponentRef<any>|null = null;\nprivate _activatedRoute: ActivatedRoute|null = null;\nprivate name: string;\n\n   activateEvents = new EventEmitter<any>();\n   deactivateEvents = new EventEmitter<any>();\n/**\n * @param {?} parentContexts\n * @param {?} location\n * @param {?} resolver\n * @param {?} name\n * @param {?} changeDetector\n */\nconstructor(\nprivate parentContexts: ChildrenOutletContexts,\nprivate location: ViewContainerRef,\nprivate resolver: ComponentFactoryResolver,  name: string,\nprivate changeDetector: ChangeDetectorRef) {\n    this.name = name || PRIMARY_OUTLET;\n    parentContexts.onChildOutletCreated(this.name, this);\n  }\n/**\n * @return {?}\n */\nngOnDestroy(): void { this.parentContexts.onChildOutletDestroyed(this.name); }\n/**\n * @return {?}\n */\nngOnInit(): void {\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      const /** @type {?} */ 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        } else {\n          // otherwise the component defined in the configuration is created\n          this.activateWith(context.route, context.resolver || null);\n        }\n      }\n    }\n  }\n/**\n * @deprecated since v4 *\n * @return {?}\n */\nget locationInjector(): Injector { return this.location.injector; }\n/**\n * @deprecated since v4 *\n * @return {?}\n */\nget locationFactoryResolver(): ComponentFactoryResolver { return this.resolver; }\n/**\n * @return {?}\n */\nget isActivated(): boolean { return !!this.activated; }\n/**\n * @return {?}\n */\nget component(): Object {\n    if (!this.activated) throw new Error('Outlet is not activated');\n    return this.activated.instance;\n  }\n/**\n * @return {?}\n */\nget activatedRoute(): ActivatedRoute {\n    if (!this.activated) throw new Error('Outlet is not activated');\n    return /** @type {?} */(( this._activatedRoute as ActivatedRoute));\n  }\n/**\n * @return {?}\n */\nget activatedRouteData() {\n    if (this._activatedRoute) {\n      return this._activatedRoute.snapshot.data;\n    }\n    return {};\n  }\n/**\n * Called when the `RouteReuseStrategy` instructs to detach the subtree\n * @return {?}\n */\ndetach(): ComponentRef<any> {\n    if (!this.activated) throw new Error('Outlet is not activated');\n    this.location.detach();\n    const /** @type {?} */ 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 * @param {?} ref\n * @param {?} activatedRoute\n * @return {?}\n */\nattach(ref: ComponentRef<any>, activatedRoute: ActivatedRoute) {\n    this.activated = ref;\n    this._activatedRoute = activatedRoute;\n    this.location.insert(ref.hostView);\n  }\n/**\n * @return {?}\n */\ndeactivate(): void {\n    if (this.activated) {\n      const /** @type {?} */ c = this.component;\n      this.activated.destroy();\n      this.activated = null;\n      this._activatedRoute = null;\n      this.deactivateEvents.emit(c);\n    }\n  }\n/**\n * @param {?} activatedRoute\n * @param {?} resolver\n * @return {?}\n */\nactivateWith(activatedRoute: ActivatedRoute, resolver: ComponentFactoryResolver|null) {\n    if (this.isActivated) {\n      throw new Error('Cannot activate an already activated outlet');\n    }\n    this._activatedRoute = activatedRoute;\n    const /** @type {?} */ snapshot = activatedRoute._futureSnapshot;\n    const /** @type {?} */ component = /** @type {?} */(( <any> /** @type {?} */((snapshot._routeConfig)).component));\n    resolver = resolver || this.resolver;\n    const /** @type {?} */ factory = resolver.resolveComponentFactory(component);\n    const /** @type {?} */ childContexts = this.parentContexts.getOrCreateContext(this.name).children;\n    const /** @type {?} */ 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  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Directive, args: [{selector: 'router-outlet', exportAs: 'outlet'}, ] },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: ChildrenOutletContexts, },\n{type: ViewContainerRef, },\n{type: ComponentFactoryResolver, },\n{type: undefined, decorators: [{ type: Attribute, args: ['name', ] }, ]},\n{type: ChangeDetectorRef, },\n];\nstatic propDecorators: {[key: string]: DecoratorInvocation[]} = {\n'activateEvents': [{ type: Output, args: ['activate', ] },],\n'deactivateEvents': [{ type: Output, args: ['deactivate', ] },],\n};\n}\n\nfunction RouterOutlet_tsickle_Closure_declarations() {\n/** @type {?} */\nRouterOutlet.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nRouterOutlet.ctorParameters;\n/** @type {?} */\nRouterOutlet.propDecorators;\n/** @type {?} */\nRouterOutlet.prototype.activated;\n/** @type {?} */\nRouterOutlet.prototype._activatedRoute;\n/** @type {?} */\nRouterOutlet.prototype.name;\n/** @type {?} */\nRouterOutlet.prototype.activateEvents;\n/** @type {?} */\nRouterOutlet.prototype.deactivateEvents;\n/** @type {?} */\nRouterOutlet.prototype.parentContexts;\n/** @type {?} */\nRouterOutlet.prototype.location;\n/** @type {?} */\nRouterOutlet.prototype.resolver;\n/** @type {?} */\nRouterOutlet.prototype.changeDetector;\n}\n\nclass OutletInjector implements Injector {\n/**\n * @param {?} route\n * @param {?} childContexts\n * @param {?} parent\n */\nconstructor(\nprivate route: ActivatedRoute,\nprivate childContexts: ChildrenOutletContexts,\nprivate parent: Injector) {}\n/**\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\nget(token: any, notFoundValue?: any): any {\n    if (token === ActivatedRoute) {\n      return this.route;\n    }\n\n    if (token === ChildrenOutletContexts) {\n      return this.childContexts;\n    }\n\n    return this.parent.get(token, notFoundValue);\n  }\n}\n\nfunction OutletInjector_tsickle_Closure_declarations() {\n/** @type {?} */\nOutletInjector.prototype.route;\n/** @type {?} */\nOutletInjector.prototype.childContexts;\n/** @type {?} */\nOutletInjector.prototype.parent;\n}\n\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\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\nimport {Compiler, Injectable, Injector, NgModuleFactoryLoader, NgModuleRef, OnDestroy} from '@angular/core';\nimport {Observable} from 'rxjs/Observable';\nimport {Subscription} from 'rxjs/Subscription';\nimport {from} from 'rxjs/observable/from';\nimport {of } from 'rxjs/observable/of';\nimport {_catch} from 'rxjs/operator/catch';\nimport {concatMap} from 'rxjs/operator/concatMap';\nimport {filter} from 'rxjs/operator/filter';\nimport {mergeAll} from 'rxjs/operator/mergeAll';\nimport {mergeMap} from 'rxjs/operator/mergeMap';\nimport {LoadedRouterConfig, Route, Routes} from './config';\nimport {Event, NavigationEnd, RouteConfigLoadEnd, RouteConfigLoadStart} from './events';\nimport {Router} from './router';\nimport {RouterConfigLoader} from './router_config_loader';\n/**\n * \\@whatItDoes Provides a preloading strategy.\n * \n * \\@experimental\n * @abstract\n */\nexport abstract class PreloadingStrategy {\n/**\n * @abstract\n * @param {?} route\n * @param {?} fn\n * @return {?}\n */\npreload(route: Route, fn: () => Observable<any>) {}\n}\n/**\n * \\@whatItDoes Provides a preloading strategy that preloads all modules as quickly as possible.\n * \n * \\@howToUse \n * \n * ```\n * RouteModule.forRoot(ROUTES, {preloadingStrategy: PreloadAllModules})\n * ```\n * \n * \\@experimental\n */\nexport class PreloadAllModules implements PreloadingStrategy {\n/**\n * @param {?} route\n * @param {?} fn\n * @return {?}\n */\npreload(route: Route, fn: () => Observable<any>): Observable<any> {\n    return _catch.call(fn(), () => of (null));\n  }\n}\n/**\n * \\@whatItDoes Provides a preloading strategy that does not preload any modules.\n * \n * \\@description \n * \n * This strategy is enabled by default.\n * \n * \\@experimental\n */\nexport class NoPreloading implements PreloadingStrategy {\n/**\n * @param {?} route\n * @param {?} fn\n * @return {?}\n */\npreload(route: Route, fn: () => Observable<any>): Observable<any> { return of (null); }\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 * \\@stable\n */\nexport class RouterPreloader implements OnDestroy {\nprivate loader: RouterConfigLoader;\nprivate subscription: Subscription;\n/**\n * @param {?} router\n * @param {?} moduleLoader\n * @param {?} compiler\n * @param {?} injector\n * @param {?} preloadingStrategy\n */\nconstructor(\nprivate router: Router, moduleLoader: NgModuleFactoryLoader, compiler: Compiler,\nprivate injector: Injector,\nprivate preloadingStrategy: PreloadingStrategy) {\n    const onStartLoad = (r: Route) => router.triggerEvent(new RouteConfigLoadStart(r));\n    const onEndLoad = (r: Route) => router.triggerEvent(new RouteConfigLoadEnd(r));\n\n    this.loader = new RouterConfigLoader(moduleLoader, compiler, onStartLoad, onEndLoad);\n  }\n/**\n * @return {?}\n */\nsetUpPreloading(): void {\n    const /** @type {?} */ navigations$ = filter.call(this.router.events, (e: Event) => e instanceof NavigationEnd);\n    this.subscription = concatMap.call(navigations$, () => this.preload()).subscribe(() => {});\n  }\n/**\n * @return {?}\n */\npreload(): Observable<any> {\n    const /** @type {?} */ ngModule = this.injector.get(NgModuleRef);\n    return this.processRoutes(ngModule, this.router.config);\n  }\n/**\n * @return {?}\n */\nngOnDestroy(): void { this.subscription.unsubscribe(); }\n/**\n * @param {?} ngModule\n * @param {?} routes\n * @return {?}\n */\nprivate processRoutes(ngModule: NgModuleRef<any>, routes: Routes): Observable<void> {\n    const /** @type {?} */ res: Observable<any>[] = [];\n    for (const /** @type {?} */ route of routes) {\n      // we already have the config loaded, just recurse\n      if (route.loadChildren && !route.canLoad && route._loadedConfig) {\n        const /** @type {?} */ childConfig = route._loadedConfig;\n        res.push(this.processRoutes(childConfig.module, childConfig.routes));\n\n        // no config loaded, fetch the config\n      } else if (route.loadChildren && !route.canLoad) {\n        res.push(this.preloadConfig(ngModule, route));\n\n        // recurse into children\n      } else if (route.children) {\n        res.push(this.processRoutes(ngModule, route.children));\n      }\n    }\n    return mergeAll.call(from(res));\n  }\n/**\n * @param {?} ngModule\n * @param {?} route\n * @return {?}\n */\nprivate preloadConfig(ngModule: NgModuleRef<any>, route: Route): Observable<void> {\n    return this.preloadingStrategy.preload(route, () => {\n      const /** @type {?} */ loaded$ = this.loader.load(ngModule.injector, route);\n      return mergeMap.call(loaded$, (config: LoadedRouterConfig) => {\n        route._loadedConfig = config;\n        return this.processRoutes(config.module, config.routes);\n      });\n    });\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: Router, },\n{type: NgModuleFactoryLoader, },\n{type: Compiler, },\n{type: Injector, },\n{type: PreloadingStrategy, },\n];\n}\n\nfunction RouterPreloader_tsickle_Closure_declarations() {\n/** @type {?} */\nRouterPreloader.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nRouterPreloader.ctorParameters;\n/** @type {?} */\nRouterPreloader.prototype.loader;\n/** @type {?} */\nRouterPreloader.prototype.subscription;\n/** @type {?} */\nRouterPreloader.prototype.router;\n/** @type {?} */\nRouterPreloader.prototype.injector;\n/** @type {?} */\nRouterPreloader.prototype.preloadingStrategy;\n}\n\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\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\nimport {AfterContentInit, ChangeDetectorRef, ContentChildren, Directive, ElementRef, Input, OnChanges, OnDestroy, QueryList, Renderer2, SimpleChanges} from '@angular/core';\nimport {Subscription} from 'rxjs/Subscription';\nimport {NavigationEnd} from '../events';\nimport {Router} from '../router';\nimport {RouterLink, RouterLinkWithHref} from './router_link';\n/**\n * \\@whatItDoes Lets you add a CSS class to an element when the link's route becomes active.\n * \n * \\@howToUse \n * \n * ```\n * <a routerLink=\"/user/bob\" routerLinkActive=\"active-link\">Bob</a>\n * ```\n * \n * \\@description \n * \n * The RouterLinkActive 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 * <a routerLink=\"/user/bob\" routerLinkActive=\"active-link\">Bob</a>\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 * <a routerLink=\"/user/bob\" routerLinkActive=\"class1 class2\">Bob</a>\n * <a routerLink=\"/user/bob\" [routerLinkActive]=\"['class1', 'class2']\">Bob</a>\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 * <a routerLink=\"/user/bob\" routerLinkActive=\"active-link\" [routerLinkActiveOptions]=\"{exact:\n * true}\">Bob</a>\n * ```\n * \n * You can assign the RouterLinkActive instance to a template variable and directly check\n * the `isActive` status.\n * ```\n * <a routerLink=\"/user/bob\" routerLinkActive #rla=\"routerLinkActive\">\n *   Bob {{ rla.isActive ? '(already open)' : ''}}\n * </a>\n * ```\n * \n * Finally, you can apply the RouterLinkActive directive to an ancestor of a RouterLink.\n * \n * ```\n * <div routerLinkActive=\"active-link\" [routerLinkActiveOptions]=\"{exact: true}\">\n *   <a routerLink=\"/user/jim\">Jim</a>\n *   <a routerLink=\"/user/bob\">Bob</a>\n * </div>\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 * \\@stable\n */\nexport class RouterLinkActive implements OnChanges,\n    OnDestroy, AfterContentInit {\n   links: QueryList<RouterLink>;\n  \n  linksWithHrefs: QueryList<RouterLinkWithHref>;\nprivate classes: string[] = [];\nprivate subscription: Subscription;\nprivate active: boolean = false;\n\n   routerLinkActiveOptions: {exact: boolean} = {exact: false};\n/**\n * @param {?} router\n * @param {?} element\n * @param {?} renderer\n * @param {?} cdr\n */\nconstructor(\nprivate router: Router,\nprivate element: ElementRef,\nprivate renderer: Renderer2,\nprivate cdr: ChangeDetectorRef) {\n    this.subscription = router.events.subscribe(s => {\n      if (s instanceof NavigationEnd) {\n        this.update();\n      }\n    });\n  }\n/**\n * @return {?}\n */\nget isActive(): boolean { return this.active; }\n/**\n * @return {?}\n */\nngAfterContentInit(): void {\n    this.links.changes.subscribe(_ => this.update());\n    this.linksWithHrefs.changes.subscribe(_ => this.update());\n    this.update();\n  }\n/**\n * @param {?} data\n * @return {?}\n */\nset routerLinkActive(data: string[]|string) {\n    const /** @type {?} */ classes = Array.isArray(data) ? data : data.split(' ');\n    this.classes = classes.filter(c => !!c);\n  }\n/**\n * @param {?} changes\n * @return {?}\n */\nngOnChanges(changes: SimpleChanges): void { this.update(); }\n/**\n * @return {?}\n */\nngOnDestroy(): void { this.subscription.unsubscribe(); }\n/**\n * @return {?}\n */\nprivate update(): void {\n    if (!this.links || !this.linksWithHrefs || !this.router.navigated) return;\n    Promise.resolve().then(() => {\n      const /** @type {?} */ hasActiveLinks = this.hasActiveLinks();\n      if (this.active !== hasActiveLinks) {\n        this.active = hasActiveLinks;\n        this.classes.forEach((c) => {\n          if (hasActiveLinks) {\n            this.renderer.addClass(this.element.nativeElement, c);\n          } else {\n            this.renderer.removeClass(this.element.nativeElement, c);\n          }\n        });\n      }\n    });\n  }\n/**\n * @param {?} router\n * @return {?}\n */\nprivate isLinkActive(router: Router): (link: (RouterLink|RouterLinkWithHref)) => boolean {\n    return (link: RouterLink | RouterLinkWithHref) =>\n               router.isActive(link.urlTree, this.routerLinkActiveOptions.exact);\n  }\n/**\n * @return {?}\n */\nprivate hasActiveLinks(): boolean {\n    return this.links.some(this.isLinkActive(this.router)) ||\n        this.linksWithHrefs.some(this.isLinkActive(this.router));\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Directive, args: [{\n  selector: '[routerLinkActive]',\n  exportAs: 'routerLinkActive',\n}, ] },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: Router, },\n{type: ElementRef, },\n{type: Renderer2, },\n{type: ChangeDetectorRef, },\n];\nstatic propDecorators: {[key: string]: DecoratorInvocation[]} = {\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}\n\nfunction RouterLinkActive_tsickle_Closure_declarations() {\n/** @type {?} */\nRouterLinkActive.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nRouterLinkActive.ctorParameters;\n/** @type {?} */\nRouterLinkActive.propDecorators;\n/** @type {?} */\nRouterLinkActive.prototype.links;\n/** @type {?} */\nRouterLinkActive.prototype.linksWithHrefs;\n/** @type {?} */\nRouterLinkActive.prototype.classes;\n/** @type {?} */\nRouterLinkActive.prototype.subscription;\n/** @type {?} */\nRouterLinkActive.prototype.active;\n/** @type {?} */\nRouterLinkActive.prototype.routerLinkActiveOptions;\n/** @type {?} */\nRouterLinkActive.prototype.router;\n/** @type {?} */\nRouterLinkActive.prototype.element;\n/** @type {?} */\nRouterLinkActive.prototype.renderer;\n/** @type {?} */\nRouterLinkActive.prototype.cdr;\n}\n\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\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\nimport {LocationStrategy} from '@angular/common';\nimport {Attribute, Directive, ElementRef, HostBinding, HostListener, Input, OnChanges, OnDestroy, Renderer2, isDevMode} from '@angular/core';\nimport {Subscription} from 'rxjs/Subscription';\n\nimport {QueryParamsHandling} from '../config';\nimport {NavigationEnd} from '../events';\nimport {Router} from '../router';\nimport {ActivatedRoute} from '../router_state';\nimport {UrlTree} from '../url_tree';\n/**\n * \\@whatItDoes Lets you link to specific parts of your app.\n * \n * \\@howToUse \n * \n * Consider the following route configuration:\n * `[{ path: 'user/:name', component: UserCmp }]`\n * \n * When linking to this `user/:name` route, you can write:\n * `<a routerLink='/user/bob'>link to user component</a>`\n * \n * \\@description \n * \n * The RouterLink directives let you link to specific parts of your app.\n * \n * When the link is static, you can use the directive as follows:\n * `<a routerLink=\"/user/bob\">link to user component</a>`\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 * <a [routerLink]=\"['/user/bob']\" [queryParams]=\"{debug: true}\" fragment=\"education\">\n *   link to user component\n * </a>\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 * <a [routerLink]=\"['/user/bob']\" preserveQueryParams preserveFragment>\n *   link to user component\n * </a>\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 *  same options for {\\@link NavigationExtras#queryParamsHandling}\n * \n * ```\n * <a [routerLink]=\"['/user/bob']\" [queryParams]=\"{debug: true}\" queryParamsHandling=\"merge\">\n *   link to user component\n * </a>\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 `<a [routerLink]=\"['/user/jim']\">Jim</a>` will generate the link\n * `/user/(jim//aux:team)`.\n * \n * \\@ngModule RouterModule\n * \n * See {\\@link Router#createUrlTree} for more information.\n * \n * \\@stable\n */\nexport class RouterLink {\n   queryParams: {[k: string]: any};\n   fragment: string;\n   queryParamsHandling: QueryParamsHandling;\n   preserveFragment: boolean;\n   skipLocationChange: boolean;\n   replaceUrl: boolean;\nprivate commands: any[] = [];\nprivate preserve: boolean;\n/**\n * @param {?} router\n * @param {?} route\n * @param {?} tabIndex\n * @param {?} renderer\n * @param {?} el\n */\nconstructor(\nprivate router: Router,\nprivate route: ActivatedRoute,\n       tabIndex: string, renderer: Renderer2, el: ElementRef) {\n    if (tabIndex == null) {\n      renderer.setAttribute(el.nativeElement, 'tabindex', '0');\n    }\n  }\n/**\n * @param {?} commands\n * @return {?}\n */\nset routerLink(commands: any[]|string) {\n    if (commands != null) {\n      this.commands = Array.isArray(commands) ? commands : [commands];\n    } else {\n      this.commands = [];\n    }\n  }\n/**\n * @deprecated 4.0.0 use `queryParamsHandling` instead.\n * @param {?} value\n * @return {?}\n */\nset preserveQueryParams(value: boolean) {\n    if (isDevMode() && /** @type {?} */(( <any>console)) && /** @type {?} */(( <any>console.warn))) {\n      console.warn('preserveQueryParams is deprecated!, use queryParamsHandling instead.');\n    }\n    this.preserve = value;\n  }\n/**\n * @return {?}\n */\nonClick(): boolean {\n    const /** @type {?} */ extras = {\n      skipLocationChange: attrBoolValue(this.skipLocationChange),\n      replaceUrl: attrBoolValue(this.replaceUrl),\n    };\n    this.router.navigateByUrl(this.urlTree, extras);\n    return true;\n  }\n/**\n * @return {?}\n */\nget urlTree(): UrlTree {\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  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Directive, args: [{selector: ':not(a)[routerLink]'}, ] },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: Router, },\n{type: ActivatedRoute, },\n{type: undefined, decorators: [{ type: Attribute, args: ['tabindex', ] }, ]},\n{type: Renderer2, },\n{type: ElementRef, },\n];\nstatic propDecorators: {[key: string]: DecoratorInvocation[]} = {\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}\n\nfunction RouterLink_tsickle_Closure_declarations() {\n/** @type {?} */\nRouterLink.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nRouterLink.ctorParameters;\n/** @type {?} */\nRouterLink.propDecorators;\n/** @type {?} */\nRouterLink.prototype.queryParams;\n/** @type {?} */\nRouterLink.prototype.fragment;\n/** @type {?} */\nRouterLink.prototype.queryParamsHandling;\n/** @type {?} */\nRouterLink.prototype.preserveFragment;\n/** @type {?} */\nRouterLink.prototype.skipLocationChange;\n/** @type {?} */\nRouterLink.prototype.replaceUrl;\n/** @type {?} */\nRouterLink.prototype.commands;\n/** @type {?} */\nRouterLink.prototype.preserve;\n/** @type {?} */\nRouterLink.prototype.router;\n/** @type {?} */\nRouterLink.prototype.route;\n}\n\n/**\n * \\@whatItDoes Lets you link to specific parts of your app.\n * \n * See {\\@link RouterLink} for more information.\n * \n * \\@ngModule RouterModule\n * \n * \\@stable\n */\nexport class RouterLinkWithHref implements OnChanges, OnDestroy {\n    target: string;\n   queryParams: {[k: string]: any};\n   fragment: string;\n   queryParamsHandling: QueryParamsHandling;\n   preserveFragment: boolean;\n   skipLocationChange: boolean;\n   replaceUrl: boolean;\nprivate commands: any[] = [];\nprivate subscription: Subscription;\nprivate preserve: boolean;\n\n  // the url displayed on the anchor element.\n   href: string;\n/**\n * @param {?} router\n * @param {?} route\n * @param {?} locationStrategy\n */\nconstructor(\nprivate router: Router,\nprivate route: ActivatedRoute,\nprivate locationStrategy: LocationStrategy) {\n    this.subscription = router.events.subscribe(s => {\n      if (s instanceof NavigationEnd) {\n        this.updateTargetUrlAndHref();\n      }\n    });\n  }\n/**\n * @param {?} commands\n * @return {?}\n */\nset routerLink(commands: any[]|string) {\n    if (commands != null) {\n      this.commands = Array.isArray(commands) ? commands : [commands];\n    } else {\n      this.commands = [];\n    }\n  }\n/**\n * @param {?} value\n * @return {?}\n */\nset preserveQueryParams(value: boolean) {\n    if (isDevMode() && /** @type {?} */(( <any>console)) && /** @type {?} */(( <any>console.warn))) {\n      console.warn('preserveQueryParams is deprecated, use queryParamsHandling instead.');\n    }\n    this.preserve = value;\n  }\n/**\n * @param {?} changes\n * @return {?}\n */\nngOnChanges(changes: {}): any { this.updateTargetUrlAndHref(); }\n/**\n * @return {?}\n */\nngOnDestroy(): any { this.subscription.unsubscribe(); }\n/**\n * @param {?} button\n * @param {?} ctrlKey\n * @param {?} metaKey\n * @param {?} shiftKey\n * @return {?}\n */\nonClick(button: number, ctrlKey: boolean, metaKey: boolean, shiftKey: boolean): boolean {\n    if (button !== 0 || ctrlKey || metaKey || shiftKey) {\n      return true;\n    }\n\n    if (typeof this.target === 'string' && this.target != '_self') {\n      return true;\n    }\n\n    const /** @type {?} */ extras = {\n      skipLocationChange: attrBoolValue(this.skipLocationChange),\n      replaceUrl: attrBoolValue(this.replaceUrl),\n    };\n    this.router.navigateByUrl(this.urlTree, extras);\n    return false;\n  }\n/**\n * @return {?}\n */\nprivate updateTargetUrlAndHref(): void {\n    this.href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.urlTree));\n  }\n/**\n * @return {?}\n */\nget urlTree(): UrlTree {\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  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Directive, args: [{selector: 'a[routerLink]'}, ] },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: Router, },\n{type: ActivatedRoute, },\n{type: LocationStrategy, },\n];\nstatic propDecorators: {[key: string]: DecoratorInvocation[]} = {\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}\n\nfunction RouterLinkWithHref_tsickle_Closure_declarations() {\n/** @type {?} */\nRouterLinkWithHref.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nRouterLinkWithHref.ctorParameters;\n/** @type {?} */\nRouterLinkWithHref.propDecorators;\n/** @type {?} */\nRouterLinkWithHref.prototype.target;\n/** @type {?} */\nRouterLinkWithHref.prototype.queryParams;\n/** @type {?} */\nRouterLinkWithHref.prototype.fragment;\n/** @type {?} */\nRouterLinkWithHref.prototype.queryParamsHandling;\n/** @type {?} */\nRouterLinkWithHref.prototype.preserveFragment;\n/** @type {?} */\nRouterLinkWithHref.prototype.skipLocationChange;\n/** @type {?} */\nRouterLinkWithHref.prototype.replaceUrl;\n/** @type {?} */\nRouterLinkWithHref.prototype.commands;\n/** @type {?} */\nRouterLinkWithHref.prototype.subscription;\n/** @type {?} */\nRouterLinkWithHref.prototype.preserve;\n/** @type {?} */\nRouterLinkWithHref.prototype.href;\n/** @type {?} */\nRouterLinkWithHref.prototype.router;\n/** @type {?} */\nRouterLinkWithHref.prototype.route;\n/** @type {?} */\nRouterLinkWithHref.prototype.locationStrategy;\n}\n\n/**\n * @param {?} s\n * @return {?}\n */\nfunction attrBoolValue(s: any): boolean {\n  return s === '' || !!s;\n}\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\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\nimport {Type} from '@angular/core';\nimport {Observable} from 'rxjs/Observable';\nimport {Observer} from 'rxjs/Observer';\nimport {of } from 'rxjs/observable/of';\n\nimport {Data, ResolveData, Route, Routes} from './config';\nimport {ActivatedRouteSnapshot, RouterStateSnapshot, inheritedParamsDataResolve} from './router_state';\nimport {PRIMARY_OUTLET, defaultUrlMatcher} from './shared';\nimport {UrlSegment, UrlSegmentGroup, UrlTree, mapChildrenIntoArray} from './url_tree';\nimport {forEach, last} from './utils/collection';\nimport {TreeNode} from './utils/tree';\nclass NoMatch {}\n/**\n * @param {?} rootComponentType\n * @param {?} config\n * @param {?} urlTree\n * @param {?} url\n * @return {?}\n */\nexport function recognize(\n    rootComponentType: Type<any>| null, config: Routes, urlTree: UrlTree,\n    url: string): Observable<RouterStateSnapshot> {\n  return new Recognizer(rootComponentType, config, urlTree, url).recognize();\n}\nclass Recognizer {\n/**\n * @param {?} rootComponentType\n * @param {?} config\n * @param {?} urlTree\n * @param {?} url\n */\nconstructor(\nprivate rootComponentType: Type<any>|null,\nprivate config: Routes,\nprivate urlTree: UrlTree,\nprivate url: string) {}\n/**\n * @return {?}\n */\nrecognize(): Observable<RouterStateSnapshot> {\n    try {\n      const /** @type {?} */ rootSegmentGroup = split(this.urlTree.root, [], [], this.config).segmentGroup;\n\n      const /** @type {?} */ children = this.processSegmentGroup(this.config, rootSegmentGroup, PRIMARY_OUTLET);\n\n      const /** @type {?} */ root = new ActivatedRouteSnapshot(\n          [], Object.freeze({}), Object.freeze(this.urlTree.queryParams), /** @type {?} */(( this.urlTree.fragment)),\n          {}, PRIMARY_OUTLET, this.rootComponentType, null, this.urlTree.root, -1, {});\n\n      const /** @type {?} */ rootNode = new TreeNode<ActivatedRouteSnapshot>(root, children);\n      const /** @type {?} */ routeState = new RouterStateSnapshot(this.url, rootNode);\n      this.inheritParamsAndData(routeState._root);\n      return of (routeState);\n\n    } catch ( /** @type {?} */e) {\n      return new Observable<RouterStateSnapshot>(\n          (obs: Observer<RouterStateSnapshot>) => obs.error(e));\n    }\n  }\n/**\n * @param {?} routeNode\n * @return {?}\n */\ninheritParamsAndData(routeNode: TreeNode<ActivatedRouteSnapshot>): void {\n    const /** @type {?} */ route = routeNode.value;\n\n    const /** @type {?} */ i = inheritedParamsDataResolve(route);\n    route.params = Object.freeze(i.params);\n    route.data = Object.freeze(i.data);\n\n    routeNode.children.forEach(n => this.inheritParamsAndData(n));\n  }\n/**\n * @param {?} config\n * @param {?} segmentGroup\n * @param {?} outlet\n * @return {?}\n */\nprocessSegmentGroup(config: Route[], segmentGroup: UrlSegmentGroup, outlet: string):\n      TreeNode<ActivatedRouteSnapshot>[] {\n    if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {\n      return this.processChildren(config, segmentGroup);\n    }\n\n    return this.processSegment(config, segmentGroup, segmentGroup.segments, outlet);\n  }\n/**\n * @param {?} config\n * @param {?} segmentGroup\n * @return {?}\n */\nprocessChildren(config: Route[], segmentGroup: UrlSegmentGroup):\n      TreeNode<ActivatedRouteSnapshot>[] {\n    const /** @type {?} */ children = mapChildrenIntoArray(\n        segmentGroup, (child, childOutlet) => this.processSegmentGroup(config, child, childOutlet));\n    checkOutletNameUniqueness(children);\n    sortActivatedRouteSnapshots(children);\n    return children;\n  }\n/**\n * @param {?} config\n * @param {?} segmentGroup\n * @param {?} segments\n * @param {?} outlet\n * @return {?}\n */\nprocessSegment(\n      config: Route[], segmentGroup: UrlSegmentGroup, segments: UrlSegment[],\n      outlet: string): TreeNode<ActivatedRouteSnapshot>[] {\n    for (const /** @type {?} */ r of config) {\n      try {\n        return this.processSegmentAgainstRoute(r, segmentGroup, segments, outlet);\n      } catch ( /** @type {?} */e) {\n        if (!(e instanceof NoMatch)) throw e;\n      }\n    }\n    if (this.noLeftoversInUrl(segmentGroup, segments, outlet)) {\n      return [];\n    }\n\n    throw new NoMatch();\n  }\n/**\n * @param {?} segmentGroup\n * @param {?} segments\n * @param {?} outlet\n * @return {?}\n */\nprivate noLeftoversInUrl(segmentGroup: UrlSegmentGroup, segments: UrlSegment[], outlet: string):\n      boolean {\n    return segments.length === 0 && !segmentGroup.children[outlet];\n  }\n/**\n * @param {?} route\n * @param {?} rawSegment\n * @param {?} segments\n * @param {?} outlet\n * @return {?}\n */\nprocessSegmentAgainstRoute(\n      route: Route, rawSegment: UrlSegmentGroup, segments: UrlSegment[],\n      outlet: string): TreeNode<ActivatedRouteSnapshot>[] {\n    if (route.redirectTo) throw new NoMatch();\n\n    if ((route.outlet || PRIMARY_OUTLET) !== outlet) throw new NoMatch();\n\n    if (route.path === '**') {\n      const /** @type {?} */ params = segments.length > 0 ? /** @type {?} */(( last(segments))).parameters : {};\n      const /** @type {?} */ snapshot = new ActivatedRouteSnapshot(\n          segments, params, Object.freeze(this.urlTree.queryParams), /** @type {?} */(( this.urlTree.fragment)),\n          getData(route), outlet, /** @type {?} */(( route.component)), route, getSourceSegmentGroup(rawSegment),\n          getPathIndexShift(rawSegment) + segments.length, getResolve(route));\n      return [new TreeNode<ActivatedRouteSnapshot>(snapshot, [])];\n    }\n\n    const {consumedSegments, parameters, lastChild} = match(rawSegment, route, segments);\n    const /** @type {?} */ rawSlicedSegments = segments.slice(lastChild);\n    const /** @type {?} */ childConfig = getChildConfig(route);\n\n    const {segmentGroup, slicedSegments} =\n        split(rawSegment, consumedSegments, rawSlicedSegments, childConfig);\n\n    const /** @type {?} */ snapshot = new ActivatedRouteSnapshot(\n        consumedSegments, parameters, Object.freeze(this.urlTree.queryParams), /** @type {?} */((\n        this.urlTree.fragment)), getData(route), outlet, /** @type {?} */(( route.component)), route,\n        getSourceSegmentGroup(rawSegment), getPathIndexShift(rawSegment) + consumedSegments.length,\n        getResolve(route));\n\n\n    if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {\n      const /** @type {?} */ children = this.processChildren(childConfig, segmentGroup);\n      return [new TreeNode<ActivatedRouteSnapshot>(snapshot, children)];\n    }\n\n    if (childConfig.length === 0 && slicedSegments.length === 0) {\n      return [new TreeNode<ActivatedRouteSnapshot>(snapshot, [])];\n    }\n\n    const /** @type {?} */ children = this.processSegment(childConfig, segmentGroup, slicedSegments, PRIMARY_OUTLET);\n    return [new TreeNode<ActivatedRouteSnapshot>(snapshot, children)];\n  }\n}\n\nfunction Recognizer_tsickle_Closure_declarations() {\n/** @type {?} */\nRecognizer.prototype.rootComponentType;\n/** @type {?} */\nRecognizer.prototype.config;\n/** @type {?} */\nRecognizer.prototype.urlTree;\n/** @type {?} */\nRecognizer.prototype.url;\n}\n\n/**\n * @param {?} nodes\n * @return {?}\n */\nfunction sortActivatedRouteSnapshots(nodes: TreeNode<ActivatedRouteSnapshot>[]): void {\n  nodes.sort((a, b) => {\n    if (a.value.outlet === PRIMARY_OUTLET) return -1;\n    if (b.value.outlet === PRIMARY_OUTLET) return 1;\n    return a.value.outlet.localeCompare(b.value.outlet);\n  });\n}\n/**\n * @param {?} route\n * @return {?}\n */\nfunction getChildConfig(route: Route): Route[] {\n  if (route.children) {\n    return route.children;\n  }\n\n  if (route.loadChildren) {\n    return /** @type {?} */(( route._loadedConfig)).routes;\n  }\n\n  return [];\n}\n/**\n * @param {?} segmentGroup\n * @param {?} route\n * @param {?} segments\n * @return {?}\n */\nfunction match(segmentGroup: UrlSegmentGroup, route: Route, segments: UrlSegment[]) {\n  if (route.path === '') {\n    if (route.pathMatch === 'full' && (segmentGroup.hasChildren() || segments.length > 0)) {\n      throw new NoMatch();\n    }\n\n    return {consumedSegments: [], lastChild: 0, parameters: {}};\n  }\n\n  const /** @type {?} */ matcher = route.matcher || defaultUrlMatcher;\n  const /** @type {?} */ res = matcher(segments, segmentGroup, route);\n  if (!res) throw new NoMatch();\n\n  const /** @type {?} */ posParams: {[n: string]: string} = {};\n  forEach( /** @type {?} */((res.posParams)), (v: UrlSegment, k: string) => { posParams[k] = v.path; });\n  const /** @type {?} */ parameters = res.consumed.length > 0 ?\n      {...posParams, ...res.consumed[res.consumed.length - 1].parameters} :\n      posParams;\n\n  return {consumedSegments: res.consumed, lastChild: res.consumed.length, parameters};\n}\n/**\n * @param {?} nodes\n * @return {?}\n */\nfunction checkOutletNameUniqueness(nodes: TreeNode<ActivatedRouteSnapshot>[]): void {\n  const /** @type {?} */ names: {[k: string]: ActivatedRouteSnapshot} = {};\n  nodes.forEach(n => {\n    const /** @type {?} */ routeWithSameOutletName = names[n.value.outlet];\n    if (routeWithSameOutletName) {\n      const /** @type {?} */ p = routeWithSameOutletName.url.map(s => s.toString()).join('/');\n      const /** @type {?} */ c = n.value.url.map(s => 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}\n/**\n * @param {?} segmentGroup\n * @return {?}\n */\nfunction getSourceSegmentGroup(segmentGroup: UrlSegmentGroup): UrlSegmentGroup {\n  let /** @type {?} */ s = segmentGroup;\n  while (s._sourceSegment) {\n    s = s._sourceSegment;\n  }\n  return s;\n}\n/**\n * @param {?} segmentGroup\n * @return {?}\n */\nfunction getPathIndexShift(segmentGroup: UrlSegmentGroup): number {\n  let /** @type {?} */ s = segmentGroup;\n  let /** @type {?} */ 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}\n/**\n * @param {?} segmentGroup\n * @param {?} consumedSegments\n * @param {?} slicedSegments\n * @param {?} config\n * @return {?}\n */\nfunction split(\n    segmentGroup: UrlSegmentGroup, consumedSegments: UrlSegment[], slicedSegments: UrlSegment[],\n    config: Route[]) {\n  if (slicedSegments.length > 0 &&\n      containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, config)) {\n    const /** @type {?} */ s = new UrlSegmentGroup(\n        consumedSegments, createChildrenForEmptyPaths(\n                              segmentGroup, consumedSegments, config,\n                              new UrlSegmentGroup(slicedSegments, segmentGroup.children)));\n    s._sourceSegment = segmentGroup;\n    s._segmentIndexShift = consumedSegments.length;\n    return {segmentGroup: s, slicedSegments: []};\n  }\n\n  if (slicedSegments.length === 0 &&\n      containsEmptyPathMatches(segmentGroup, slicedSegments, config)) {\n    const /** @type {?} */ s = new UrlSegmentGroup(\n        segmentGroup.segments, addEmptyPathsToChildrenIfNeeded(\n                                   segmentGroup, slicedSegments, config, segmentGroup.children));\n    s._sourceSegment = segmentGroup;\n    s._segmentIndexShift = consumedSegments.length;\n    return {segmentGroup: s, slicedSegments};\n  }\n\n  const /** @type {?} */ s = new UrlSegmentGroup(segmentGroup.segments, segmentGroup.children);\n  s._sourceSegment = segmentGroup;\n  s._segmentIndexShift = consumedSegments.length;\n  return {segmentGroup: s, slicedSegments};\n}\n/**\n * @param {?} segmentGroup\n * @param {?} slicedSegments\n * @param {?} routes\n * @param {?} children\n * @return {?}\n */\nfunction addEmptyPathsToChildrenIfNeeded(\n    segmentGroup: UrlSegmentGroup, slicedSegments: UrlSegment[], routes: Route[],\n    children: {[name: string]: UrlSegmentGroup}): {[name: string]: UrlSegmentGroup} {\n  const /** @type {?} */ res: {[name: string]: UrlSegmentGroup} = {};\n  for (const /** @type {?} */ r of routes) {\n    if (emptyPathMatch(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {\n      const /** @type {?} */ s = new UrlSegmentGroup([], {});\n      s._sourceSegment = segmentGroup;\n      s._segmentIndexShift = segmentGroup.segments.length;\n      res[getOutlet(r)] = s;\n    }\n  }\n  return {...children, ...res};\n}\n/**\n * @param {?} segmentGroup\n * @param {?} consumedSegments\n * @param {?} routes\n * @param {?} primarySegment\n * @return {?}\n */\nfunction createChildrenForEmptyPaths(\n    segmentGroup: UrlSegmentGroup, consumedSegments: UrlSegment[], routes: Route[],\n    primarySegment: UrlSegmentGroup): {[name: string]: UrlSegmentGroup} {\n  const /** @type {?} */ res: {[name: string]: UrlSegmentGroup} = {};\n  res[PRIMARY_OUTLET] = primarySegment;\n  primarySegment._sourceSegment = segmentGroup;\n  primarySegment._segmentIndexShift = consumedSegments.length;\n\n  for (const /** @type {?} */ r of routes) {\n    if (r.path === '' && getOutlet(r) !== PRIMARY_OUTLET) {\n      const /** @type {?} */ s = new UrlSegmentGroup([], {});\n      s._sourceSegment = segmentGroup;\n      s._segmentIndexShift = consumedSegments.length;\n      res[getOutlet(r)] = s;\n    }\n  }\n  return res;\n}\n/**\n * @param {?} segmentGroup\n * @param {?} slicedSegments\n * @param {?} routes\n * @return {?}\n */\nfunction containsEmptyPathMatchesWithNamedOutlets(\n    segmentGroup: UrlSegmentGroup, slicedSegments: UrlSegment[], routes: Route[]): boolean {\n  return routes.some(\n      r => emptyPathMatch(segmentGroup, slicedSegments, r) && getOutlet(r) !== PRIMARY_OUTLET);\n}\n/**\n * @param {?} segmentGroup\n * @param {?} slicedSegments\n * @param {?} routes\n * @return {?}\n */\nfunction containsEmptyPathMatches(\n    segmentGroup: UrlSegmentGroup, slicedSegments: UrlSegment[], routes: Route[]): boolean {\n  return routes.some(r => emptyPathMatch(segmentGroup, slicedSegments, r));\n}\n/**\n * @param {?} segmentGroup\n * @param {?} slicedSegments\n * @param {?} r\n * @return {?}\n */\nfunction emptyPathMatch(\n    segmentGroup: UrlSegmentGroup, slicedSegments: UrlSegment[], r: Route): boolean {\n  if ((segmentGroup.hasChildren() || slicedSegments.length > 0) && r.pathMatch === 'full') {\n    return false;\n  }\n\n  return r.path === '' && r.redirectTo === undefined;\n}\n/**\n * @param {?} route\n * @return {?}\n */\nfunction getOutlet(route: Route): string {\n  return route.outlet || PRIMARY_OUTLET;\n}\n/**\n * @param {?} route\n * @return {?}\n */\nfunction getData(route: Route): Data {\n  return route.data || {};\n}\n/**\n * @param {?} route\n * @return {?}\n */\nfunction getResolve(route: Route): ResolveData {\n  return route.resolve || {};\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\nimport {ComponentRef} from '@angular/core';\n\nimport {OutletContext} from './router_outlet_context';\nimport {ActivatedRoute, ActivatedRouteSnapshot} from './router_state';\nimport {TreeNode} from './utils/tree';\n\n/**\n * @whatItDoes Represents the detached route tree.\n *\n * This is an opaque value the router will give to a custom route reuse strategy\n * to store and retrieve later on.\n *\n * @experimental\n */\nexport type DetachedRouteHandle = {};\n\n/** @internal */\nexport type DetachedRouteHandleInternal = {\n  contexts: Map<string, OutletContext>,\n  componentRef: ComponentRef<any>,\n  route: TreeNode<ActivatedRoute>,\n};\n/**\n * \\@whatItDoes Provides a way to customize when activated routes get reused.\n * \n * \\@experimental\n * @abstract\n */\nexport abstract class RouteReuseStrategy {\n/**\n * Determines if this route (and its subtree) should be detached to be reused later\n * @abstract\n * @param {?} route\n * @return {?}\n */\nshouldDetach(route: ActivatedRouteSnapshot) {}\n/**\n * Stores the detached route.\n * \n * Storing a `null` value should erase the previously stored value.\n * @abstract\n * @param {?} route\n * @param {?} handle\n * @return {?}\n */\nstore(route: ActivatedRouteSnapshot, handle: DetachedRouteHandle|null) {}\n/**\n * Determines if this route (and its subtree) should be reattached\n * @abstract\n * @param {?} route\n * @return {?}\n */\nshouldAttach(route: ActivatedRouteSnapshot) {}\n/**\n * Retrieves the previously stored route\n * @abstract\n * @param {?} route\n * @return {?}\n */\nretrieve(route: ActivatedRouteSnapshot) {}\n/**\n * Determines if a route should be reused\n * @abstract\n * @param {?} future\n * @param {?} curr\n * @return {?}\n */\nshouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot) {}\n}\n/**\n * Does not detach any subtrees. Reuses routes as long as their route config is the same.\n */\nexport class DefaultRouteReuseStrategy implements RouteReuseStrategy {\n/**\n * @param {?} route\n * @return {?}\n */\nshouldDetach(route: ActivatedRouteSnapshot): boolean { return false; }\n/**\n * @param {?} route\n * @param {?} detachedTree\n * @return {?}\n */\nstore(route: ActivatedRouteSnapshot, detachedTree: DetachedRouteHandle): void {}\n/**\n * @param {?} route\n * @return {?}\n */\nshouldAttach(route: ActivatedRouteSnapshot): boolean { return false; }\n/**\n * @param {?} route\n * @return {?}\n */\nretrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle|null { return null; }\n/**\n * @param {?} future\n * @param {?} curr\n * @return {?}\n */\nshouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot): boolean {\n    return future.routeConfig === curr.routeConfig;\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\nimport {Compiler, InjectionToken, Injector, NgModuleFactory, NgModuleFactoryLoader, NgModuleRef} from '@angular/core';\nimport {Observable} from 'rxjs/Observable';\nimport {fromPromise} from 'rxjs/observable/fromPromise';\nimport {of } from 'rxjs/observable/of';\nimport {map} from 'rxjs/operator/map';\nimport {mergeMap} from 'rxjs/operator/mergeMap';\nimport {LoadChildren, LoadedRouterConfig, Route} from './config';\nimport {flatten, wrapIntoObservable} from './utils/collection';\n/**\n * \\@docsNotRequired\n * \\@experimental\n */\nexport const ROUTES = new InjectionToken<Route[][]>('ROUTES');\nexport class RouterConfigLoader {\n/**\n * @param {?} loader\n * @param {?} compiler\n * @param {?=} onLoadStartListener\n * @param {?=} onLoadEndListener\n */\nconstructor(\nprivate loader: NgModuleFactoryLoader,\nprivate compiler: Compiler,\nprivate onLoadStartListener?: (r: Route) => void,\nprivate onLoadEndListener?: (r: Route) => void) {}\n/**\n * @param {?} parentInjector\n * @param {?} route\n * @return {?}\n */\nload(parentInjector: Injector, route: Route): Observable<LoadedRouterConfig> {\n    if (this.onLoadStartListener) {\n      this.onLoadStartListener(route);\n    }\n\n    const /** @type {?} */ moduleFactory$ = this.loadModuleFactory( /** @type {?} */((route.loadChildren)));\n\n    return map.call(moduleFactory$, (factory: NgModuleFactory<any>) => {\n      if (this.onLoadEndListener) {\n        this.onLoadEndListener(route);\n      }\n\n      const /** @type {?} */ module = factory.create(parentInjector);\n\n      return new LoadedRouterConfig(flatten(module.injector.get(ROUTES)), module);\n    });\n  }\n/**\n * @param {?} loadChildren\n * @return {?}\n */\nprivate loadModuleFactory(loadChildren: LoadChildren): Observable<NgModuleFactory<any>> {\n    if (typeof loadChildren === 'string') {\n      return fromPromise(this.loader.load(loadChildren));\n    } else {\n      return mergeMap.call(wrapIntoObservable(loadChildren()), (t: any) => {\n        if (t instanceof NgModuleFactory) {\n          return of (t);\n        } else {\n          return fromPromise(this.compiler.compileModuleAsync(t));\n        }\n      });\n    }\n  }\n}\n\nfunction RouterConfigLoader_tsickle_Closure_declarations() {\n/** @type {?} */\nRouterConfigLoader.prototype.loader;\n/** @type {?} */\nRouterConfigLoader.prototype.compiler;\n/** @type {?} */\nRouterConfigLoader.prototype.onLoadStartListener;\n/** @type {?} */\nRouterConfigLoader.prototype.onLoadEndListener;\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\nimport {UrlTree} from './url_tree';\n/**\n * \\@whatItDoes Provides a way to migrate AngularJS applications to Angular.\n * \n * \\@experimental\n * @abstract\n */\nexport abstract class UrlHandlingStrategy {\n/**\n * Tells the router if this URL should be processed.\n * \n * When it returns true, the router will execute the regular navigation.\n * When it returns false, the router will set the router state to an empty state.\n * As a result, all the active components will be destroyed.\n * \n * @abstract\n * @param {?} url\n * @return {?}\n */\nshouldProcessUrl(url: UrlTree) {}\n/**\n * Extracts the part of the URL that should be handled by the router.\n * The rest of the URL will remain untouched.\n * @abstract\n * @param {?} url\n * @return {?}\n */\nextract(url: UrlTree) {}\n/**\n * Merges the URL fragment with the rest of the URL.\n * @abstract\n * @param {?} newUrlPart\n * @param {?} rawUrl\n * @return {?}\n */\nmerge(newUrlPart: UrlTree, rawUrl: UrlTree) {}\n}\n/**\n * \\@experimental\n */\nexport class DefaultUrlHandlingStrategy implements UrlHandlingStrategy {\n/**\n * @param {?} url\n * @return {?}\n */\nshouldProcessUrl(url: UrlTree): boolean { return true; }\n/**\n * @param {?} url\n * @return {?}\n */\nextract(url: UrlTree): UrlTree { return url; }\n/**\n * @param {?} newUrlPart\n * @param {?} wholeUrl\n * @return {?}\n */\nmerge(newUrlPart: UrlTree, wholeUrl: UrlTree): UrlTree { return newUrlPart; }\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\nimport {Location} from '@angular/common';\nimport {Compiler, Injector, NgModuleFactoryLoader, NgModuleRef, Type, isDevMode} from '@angular/core';\nimport {BehaviorSubject} from 'rxjs/BehaviorSubject';\nimport {Observable} from 'rxjs/Observable';\nimport {Subject} from 'rxjs/Subject';\nimport {Subscription} from 'rxjs/Subscription';\nimport {from} from 'rxjs/observable/from';\nimport {of } from 'rxjs/observable/of';\nimport {concatMap} from 'rxjs/operator/concatMap';\nimport {every} from 'rxjs/operator/every';\nimport {first} from 'rxjs/operator/first';\nimport {last} from 'rxjs/operator/last';\nimport {map} from 'rxjs/operator/map';\nimport {mergeMap} from 'rxjs/operator/mergeMap';\nimport {reduce} from 'rxjs/operator/reduce';\n\nimport {applyRedirects} from './apply_redirects';\nimport {LoadedRouterConfig, QueryParamsHandling, ResolveData, Route, Routes, RunGuardsAndResolvers, validateConfig} from './config';\nimport {createRouterState} from './create_router_state';\nimport {createUrlTree} from './create_url_tree';\nimport {Event, GuardsCheckEnd, GuardsCheckStart, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, ResolveEnd, ResolveStart, RouteConfigLoadEnd, RouteConfigLoadStart, RoutesRecognized} from './events';\nimport {recognize} from './recognize';\nimport {DefaultRouteReuseStrategy, DetachedRouteHandleInternal, RouteReuseStrategy} from './route_reuse_strategy';\nimport {RouterConfigLoader} from './router_config_loader';\nimport {ChildrenOutletContexts, OutletContext} from './router_outlet_context';\nimport {ActivatedRoute, ActivatedRouteSnapshot, RouterState, RouterStateSnapshot, advanceActivatedRoute, createEmptyState, equalParamsAndUrlSegments, inheritedParamsDataResolve} from './router_state';\nimport {Params, isNavigationCancelingError} from './shared';\nimport {DefaultUrlHandlingStrategy, UrlHandlingStrategy} from './url_handling_strategy';\nimport {UrlSerializer, UrlTree, containsTree, createEmptyUrlTree} from './url_tree';\nimport {andObservables, forEach, shallowEqual, waitForMap, wrapIntoObservable} from './utils/collection';\nimport {TreeNode} from './utils/tree';\n\ndeclare let Zone: any;\n\n/**\n * @whatItDoes Represents the extra options used during navigation.\n *\n * @stable\n */\nexport interface NavigationExtras {\n  /**\n  * Enables relative navigation from the current ActivatedRoute.\n  *\n  * Configuration:\n  *\n  * ```\n  * [{\n  *   path: 'parent',\n  *   component: ParentComponent,\n  *   children: [{\n  *     path: 'list',\n  *     component: ListComponent\n  *   },{\n  *     path: 'child',\n  *     component: ChildComponent\n  *   }]\n  * }]\n  * ```\n  *\n  * Navigate to list route from child route:\n  *\n  * ```\n  *  @Component({...})\n  *  class ChildComponent {\n  *    constructor(private router: Router, private route: ActivatedRoute) {}\n  *\n  *    go() {\n  *      this.router.navigate(['../list'], { relativeTo: this.route });\n  *    }\n  *  }\n  * ```\n  */\n  relativeTo?: ActivatedRoute|null;\n\n  /**\n  * Sets query parameters to the URL.\n  *\n  * ```\n  * // Navigate to /results?page=1\n  * this.router.navigate(['/results'], { queryParams: { page: 1 } });\n  * ```\n  */\n  queryParams?: Params|null;\n\n  /**\n  * Sets the hash fragment for the URL.\n  *\n  * ```\n  * // Navigate to /results#top\n  * this.router.navigate(['/results'], { fragment: 'top' });\n  * ```\n  */\n  fragment?: string;\n\n  /**\n  * Preserves the query parameters for the next navigation.\n  *\n  * deprecated, use `queryParamsHandling` instead\n  *\n  * ```\n  * // Preserve query params from /results?page=1 to /view?page=1\n  * this.router.navigate(['/view'], { preserveQueryParams: true });\n  * ```\n  *\n  * @deprecated since v4\n  */\n  preserveQueryParams?: boolean;\n\n  /**\n  *  config strategy to handle the query parameters for the next navigation.\n  *\n  * ```\n  * // from /results?page=1 to /view?page=1&page=2\n  * this.router.navigate(['/view'], { queryParams: { page: 2 },  queryParamsHandling: \"merge\" });\n  * ```\n  */\n  queryParamsHandling?: QueryParamsHandling|null;\n  /**\n  * Preserves the fragment for the next navigation\n  *\n  * ```\n  * // Preserve fragment from /results#top to /view#top\n  * this.router.navigate(['/view'], { preserveFragment: true });\n  * ```\n  */\n  preserveFragment?: boolean;\n  /**\n  * Navigates without pushing a new state into history.\n  *\n  * ```\n  * // Navigate silently to /view\n  * this.router.navigate(['/view'], { skipLocationChange: true });\n  * ```\n  */\n  skipLocationChange?: boolean;\n  /**\n  * Navigates while replacing the current state in history.\n  *\n  * ```\n  * // Navigate to /view\n  * this.router.navigate(['/view'], { replaceUrl: true });\n  * ```\n  */\n  replaceUrl?: boolean;\n}\n\n/**\n * @whatItDoes Error handler that is invoked when a navigation errors.\n *\n * @description\n * If the handler returns a value, the navigation promise will be resolved with this value.\n * If the handler throws an exception, the navigation promise will be rejected with\n * the exception.\n *\n * @stable\n */\nexport type ErrorHandler = (error: any) => any;\n/**\n * @param {?} error\n * @return {?}\n */\nfunction defaultErrorHandler(error: any): any {\n  throw error;\n}\n\ntype NavigationSource = 'imperative' | 'popstate' | 'hashchange';\n\ntype NavigationParams = {\n  id: number,\n  rawUrl: UrlTree,\n  extras: NavigationExtras,\n  resolve: any,\n  reject: any,\n  promise: Promise<boolean>,\n  source: NavigationSource,\n};\n\n/**\n * @internal\n */\nexport type RouterHook = (snapshot: RouterStateSnapshot) => Observable<void>;\n/**\n * \\@internal\n * @param {?} snapshot\n * @return {?}\n */\nfunction defaultRouterHook(snapshot: RouterStateSnapshot): Observable<void> {\n  return /** @type {?} */(( of (null) as any));\n}\n/**\n * \\@whatItDoes Provides the navigation and url manipulation capabilities.\n * \n * See {\\@link Routes} for more details and examples.\n * \n * \\@ngModule RouterModule\n * \n * \\@stable\n */\nexport class Router {\nprivate currentUrlTree: UrlTree;\nprivate rawUrlTree: UrlTree;\nprivate navigations = new BehaviorSubject<NavigationParams>( /** @type {?} */((null)));\nprivate routerEvents = new Subject<Event>();\nprivate currentRouterState: RouterState;\nprivate locationSubscription: Subscription;\nprivate navigationId: number = 0;\nprivate configLoader: RouterConfigLoader;\nprivate ngModule: NgModuleRef<any>;\n/**\n * Error handler that is invoked when a navigation errors.\n * \n * See {\\@link ErrorHandler} for more information.\n */\nerrorHandler: ErrorHandler = defaultErrorHandler;\n/**\n * Indicates if at least one navigation happened.\n */\nnavigated: boolean = false;\n/**\n * Used by RouterModule. This allows us to\n * pause the navigation either before preactivation or after it.\n * \\@internal\n */\nhooks: {beforePreactivation: RouterHook, afterPreactivation: RouterHook} = {\n    beforePreactivation: defaultRouterHook,\n    afterPreactivation: defaultRouterHook\n  };\n/**\n * Extracts and merges URLs. Used for AngularJS to Angular migrations.\n */\nurlHandlingStrategy: UrlHandlingStrategy = new DefaultUrlHandlingStrategy();\n\n  routeReuseStrategy: RouteReuseStrategy = new DefaultRouteReuseStrategy();\n/**\n * @param {?} rootComponentType\n * @param {?} urlSerializer\n * @param {?} rootContexts\n * @param {?} location\n * @param {?} injector\n * @param {?} loader\n * @param {?} compiler\n * @param {?} config\n */\nconstructor(\nprivate rootComponentType: Type<any>|null,\nprivate urlSerializer: UrlSerializer,\nprivate rootContexts: ChildrenOutletContexts,\nprivate location: Location, injector: Injector,\n      loader: NgModuleFactoryLoader, compiler: Compiler,\npublic config: Routes) {\n    const onLoadStart = (r: Route) => this.triggerEvent(new RouteConfigLoadStart(r));\n    const onLoadEnd = (r: Route) => this.triggerEvent(new RouteConfigLoadEnd(r));\n\n    this.ngModule = injector.get(NgModuleRef);\n\n    this.resetConfig(config);\n    this.currentUrlTree = createEmptyUrlTree();\n    this.rawUrlTree = this.currentUrlTree;\n\n    this.configLoader = new RouterConfigLoader(loader, compiler, onLoadStart, onLoadEnd);\n    this.currentRouterState = 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 * @param {?} rootComponentType\n * @return {?}\n */\nresetRootComponentType(rootComponentType: Type<any>): void {\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.currentRouterState.root.component = this.rootComponentType;\n  }\n/**\n * Sets up the location change listener and performs the initial navigation.\n * @return {?}\n */\ninitialNavigation(): void {\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 * @return {?}\n */\nsetUpLocationChangeListener(): void {\n    // Zone.current.wrap is needed because of the issue with RxJS scheduler,\n    // which does not work properly with zone.js in IE and Safari\n    if (!this.locationSubscription) {\n      this.locationSubscription = /** @type {?} */(( <any>this.location.subscribe(Zone.current.wrap((change: any) => {\n        const /** @type {?} */ rawUrlTree = this.urlSerializer.parse(change['url']);\n        const /** @type {?} */ source: NavigationSource = change['type'] === 'popstate' ? 'popstate' : 'hashchange';\n        setTimeout(() => { this.scheduleNavigation(rawUrlTree, source, {replaceUrl: true}); }, 0);\n      }))));\n    }\n  }\n/**\n * The current route state\n * @return {?}\n */\nget routerState(): RouterState { return this.currentRouterState; }\n/**\n * The current url\n * @return {?}\n */\nget url(): string { return this.serializeUrl(this.currentUrlTree); }\n/**\n * An observable of router events\n * @return {?}\n */\nget events(): Observable<Event> { return this.routerEvents; }\n/**\n * \\@internal\n * @param {?} e\n * @return {?}\n */\ntriggerEvent(e: Event): void { this.routerEvents.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 * @param {?} config\n * @return {?}\n */\nresetConfig(config: Routes): void {\n    validateConfig(config);\n    this.config = config;\n    this.navigated = false;\n  }\n/**\n * \\@docsNotRequired\n * @return {?}\n */\nngOnDestroy(): void { this.dispose(); }\n/**\n * Disposes of the router\n * @return {?}\n */\ndispose(): void {\n    if (this.locationSubscription) {\n      this.locationSubscription.unsubscribe();\n      this.locationSubscription = /** @type {?} */(( 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 * @param {?} commands\n * @param {?=} navigationExtras\n * @return {?}\n */\ncreateUrlTree(commands: any[], navigationExtras: NavigationExtras = {}): UrlTree {\n    const {relativeTo,          queryParams,         fragment,\n           preserveQueryParams, queryParamsHandling, preserveFragment} = navigationExtras;\n    if (isDevMode() && preserveQueryParams && /** @type {?} */(( <any>console)) && /** @type {?} */(( <any>console.warn))) {\n      console.warn('preserveQueryParams is deprecated, use queryParamsHandling instead.');\n    }\n    const /** @type {?} */ a = relativeTo || this.routerState.root;\n    const /** @type {?} */ f = preserveFragment ? this.currentUrlTree.fragment : fragment;\n    let /** @type {?} */ q: Params|null = null;\n    if (queryParamsHandling) {\n      switch (queryParamsHandling) {\n        case 'merge':\n          q = {...this.currentUrlTree.queryParams, ...queryParams};\n          break;\n        case 'preserve':\n          q = this.currentUrlTree.queryParams;\n          break;\n        default:\n          q = queryParams || null;\n      }\n    } else {\n      q = preserveQueryParams ? this.currentUrlTree.queryParams : queryParams || null;\n    }\n    return createUrlTree(a, this.currentUrlTree, commands, /** @type {?} */(( q)), /** @type {?} */(( 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 * @param {?} url\n * @param {?=} extras\n * @return {?}\n */\nnavigateByUrl(url: string|UrlTree, extras: NavigationExtras = {skipLocationChange: false}):\n      Promise<boolean> {\n    const /** @type {?} */ urlTree = url instanceof UrlTree ? url : this.parseUrl(url);\n    const /** @type {?} */ mergedTree = this.urlHandlingStrategy.merge(urlTree, this.rawUrlTree);\n\n    return this.scheduleNavigation(mergedTree, 'imperative', 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 * @param {?} commands\n * @param {?=} extras\n * @return {?}\n */\nnavigate(commands: any[], extras: NavigationExtras = {skipLocationChange: false}):\n      Promise<boolean> {\n    validateCommands(commands);\n    if (typeof extras.queryParams === 'object' && extras.queryParams !== null) {\n      extras.queryParams = this.removeEmptyProps(extras.queryParams);\n    }\n    return this.navigateByUrl(this.createUrlTree(commands, extras), extras);\n  }\n/**\n * Serializes a {\\@link UrlTree} into a string\n * @param {?} url\n * @return {?}\n */\nserializeUrl(url: UrlTree): string { return this.urlSerializer.serialize(url); }\n/**\n * Parses a string into a {\\@link UrlTree}\n * @param {?} url\n * @return {?}\n */\nparseUrl(url: string): UrlTree { return this.urlSerializer.parse(url); }\n/**\n * Returns whether the url is activated\n * @param {?} url\n * @param {?} exact\n * @return {?}\n */\nisActive(url: string|UrlTree, exact: boolean): boolean {\n    if (url instanceof UrlTree) {\n      return containsTree(this.currentUrlTree, url, exact);\n    }\n\n    const /** @type {?} */ urlTree = this.urlSerializer.parse(url);\n    return containsTree(this.currentUrlTree, urlTree, exact);\n  }\n/**\n * @param {?} params\n * @return {?}\n */\nprivate removeEmptyProps(params: Params): Params {\n    return Object.keys(params).reduce((result: Params, key: string) => {\n      const /** @type {?} */ value: any = params[key];\n      if (value !== null && value !== undefined) {\n        result[key] = value;\n      }\n      return result;\n    }, {});\n  }\n/**\n * @return {?}\n */\nprivate processNavigations(): void {\n    concatMap\n        .call(\n            this.navigations,\n            (nav: NavigationParams) => {\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(() => {});\n              } else {\n                return /** @type {?} */(( <any>of (null)));\n              }\n            })\n        .subscribe(() => {});\n  }\n/**\n * @param {?} rawUrl\n * @param {?} source\n * @param {?} extras\n * @return {?}\n */\nprivate scheduleNavigation(rawUrl: UrlTree, source: NavigationSource, extras: NavigationExtras):\n      Promise<boolean> {\n    const /** @type {?} */ lastNavigation = this.navigations.value;\n\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\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.\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\n    let /** @type {?} */ resolve: any = null;\n    let /** @type {?} */ reject: any = null;\n\n    const /** @type {?} */ promise = new Promise<boolean>((res, rej) => {\n      resolve = res;\n      reject = rej;\n    });\n\n    const /** @type {?} */ id = ++this.navigationId;\n    this.navigations.next({id, source, rawUrl, extras, resolve, reject, promise});\n\n    // Make sure that the error is propagated even though `processNavigations` catch\n    // handler does not rethrow\n    return promise.catch((e: any) => Promise.reject(e));\n  }\n/**\n * @param {?} __0\n * @return {?}\n */\nprivate executeScheduledNavigation({id, rawUrl, extras, resolve, reject}: NavigationParams):\n      void {\n    const /** @type {?} */ url = this.urlHandlingStrategy.extract(rawUrl);\n    const /** @type {?} */ urlTransition = !this.navigated || url.toString() !== this.currentUrlTree.toString();\n\n    if (urlTransition && this.urlHandlingStrategy.shouldProcessUrl(rawUrl)) {\n      this.routerEvents.next(new NavigationStart(id, this.serializeUrl(url)));\n      Promise.resolve()\n          .then(\n              (_) => this.runNavigate(\n                  url, rawUrl, !!extras.skipLocationChange, !!extras.replaceUrl, id, null))\n          .then(resolve, reject);\n\n      // we cannot process the current URL, but we could process the previous one =>\n      // we need to do some cleanup\n    } else if (\n        urlTransition && this.rawUrlTree &&\n        this.urlHandlingStrategy.shouldProcessUrl(this.rawUrlTree)) {\n      this.routerEvents.next(new NavigationStart(id, this.serializeUrl(url)));\n      Promise.resolve()\n          .then(\n              (_) => this.runNavigate(\n                  url, rawUrl, false, false, id,\n                  createEmptyState(url, this.rootComponentType).snapshot))\n          .then(resolve, reject);\n\n    } else {\n      this.rawUrlTree = rawUrl;\n      resolve(null);\n    }\n  }\n/**\n * @param {?} url\n * @param {?} rawUrl\n * @param {?} shouldPreventPushState\n * @param {?} shouldReplaceUrl\n * @param {?} id\n * @param {?} precreatedState\n * @return {?}\n */\nprivate runNavigate(\n      url: UrlTree, rawUrl: UrlTree, shouldPreventPushState: boolean, shouldReplaceUrl: boolean,\n      id: number, precreatedState: RouterStateSnapshot|null): Promise<boolean> {\n    if (id !== this.navigationId) {\n      this.location.go(this.urlSerializer.serialize(this.currentUrlTree));\n      this.routerEvents.next(new NavigationCancel(\n          id, this.serializeUrl(url),\n          `Navigation ID ${id} is not equal to the current navigation id ${this.navigationId}`));\n      return Promise.resolve(false);\n    }\n\n    return new Promise((resolvePromise, rejectPromise) => {\n      // create an observable of the url and route state snapshot\n      // this operation do not result in any side effects\n      let /** @type {?} */ urlAndSnapshot$: Observable<{appliedUrl: UrlTree, snapshot: RouterStateSnapshot}>;\n      if (!precreatedState) {\n        const /** @type {?} */ moduleInjector = this.ngModule.injector;\n        const /** @type {?} */ redirectsApplied$ =\n            applyRedirects(moduleInjector, this.configLoader, this.urlSerializer, url, this.config);\n\n        urlAndSnapshot$ = mergeMap.call(redirectsApplied$, (appliedUrl: UrlTree) => {\n          return map.call(\n              recognize(\n                  this.rootComponentType, this.config, appliedUrl, this.serializeUrl(appliedUrl)),\n              (snapshot: any) => {\n\n                this.routerEvents.next(new RoutesRecognized(\n                    id, this.serializeUrl(url), this.serializeUrl(appliedUrl), snapshot));\n\n                return {appliedUrl, snapshot};\n              });\n        });\n      } else {\n        urlAndSnapshot$ = of ({appliedUrl: url, snapshot: precreatedState});\n      }\n\n      const /** @type {?} */ beforePreactivationDone$ = mergeMap.call(\n          urlAndSnapshot$, (p: {appliedUrl: string, snapshot: RouterStateSnapshot}) => {\n            return map.call(this.hooks.beforePreactivation(p.snapshot), () => p);\n          });\n\n      // run preactivation: guards and data resolvers\n      let /** @type {?} */ preActivation: PreActivation;\n\n      const /** @type {?} */ preactivationTraverse$ = map.call(\n          beforePreactivationDone$,\n          ({appliedUrl, snapshot}: {appliedUrl: string, snapshot: RouterStateSnapshot}) => {\n            const /** @type {?} */ moduleInjector = this.ngModule.injector;\n            preActivation =\n                new PreActivation(snapshot, this.currentRouterState.snapshot, moduleInjector);\n            preActivation.traverse(this.rootContexts);\n            return {appliedUrl, snapshot};\n          });\n\n      const /** @type {?} */ preactivationCheckGuards$ = mergeMap.call(\n          preactivationTraverse$,\n          ({appliedUrl, snapshot}: {appliedUrl: string, snapshot: RouterStateSnapshot}) => {\n            if (this.navigationId !== id) return of (false);\n\n            this.triggerEvent(\n                new GuardsCheckStart(id, this.serializeUrl(url), appliedUrl, snapshot));\n\n            return map.call(preActivation.checkGuards(), (shouldActivate: boolean) => {\n              this.triggerEvent(new GuardsCheckEnd(\n                  id, this.serializeUrl(url), appliedUrl, snapshot, shouldActivate));\n              return {appliedUrl: appliedUrl, snapshot: snapshot, shouldActivate: shouldActivate};\n            });\n          });\n\n      const /** @type {?} */ preactivationResolveData$ = mergeMap.call(\n          preactivationCheckGuards$,\n          (p: {appliedUrl: string, snapshot: RouterStateSnapshot, shouldActivate: boolean}) => {\n            if (this.navigationId !== id) return of (false);\n\n            if (p.shouldActivate && preActivation.isActivating()) {\n              this.triggerEvent(\n                  new ResolveStart(id, this.serializeUrl(url), p.appliedUrl, p.snapshot));\n              return map.call(preActivation.resolveData(), () => {\n                this.triggerEvent(\n                    new ResolveEnd(id, this.serializeUrl(url), p.appliedUrl, p.snapshot));\n                return p;\n              });\n            } else {\n              return of (p);\n            }\n          });\n\n      const /** @type {?} */ preactivationDone$ = mergeMap.call(preactivationResolveData$, (p: any) => {\n        return map.call(this.hooks.afterPreactivation(p.snapshot), () => p);\n      });\n\n\n      // create router state\n      // this operation has side effects => route state is being affected\n      const /** @type {?} */ routerState$ =\n          map.call(preactivationDone$, ({appliedUrl, snapshot, shouldActivate}: any) => {\n            if (shouldActivate) {\n              const /** @type {?} */ state =\n                  createRouterState(this.routeReuseStrategy, snapshot, this.currentRouterState);\n              return {appliedUrl, state, shouldActivate};\n            } else {\n              return {appliedUrl, state: null, shouldActivate};\n            }\n          });\n\n\n      // applied the new router state\n      // this operation has side effects\n      let /** @type {?} */ navigationIsSuccessful: boolean;\n      const /** @type {?} */ storedState = this.currentRouterState;\n      const /** @type {?} */ storedUrl = this.currentUrlTree;\n\n      routerState$\n          .forEach(({appliedUrl, state, shouldActivate}: any) => {\n            if (!shouldActivate || id !== this.navigationId) {\n              navigationIsSuccessful = false;\n              return;\n            }\n\n            this.currentUrlTree = appliedUrl;\n            this.rawUrlTree = this.urlHandlingStrategy.merge(this.currentUrlTree, rawUrl);\n\n            this.currentRouterState = state;\n\n            if (!shouldPreventPushState) {\n              const /** @type {?} */ path = this.urlSerializer.serialize(this.rawUrlTree);\n              if (this.location.isCurrentPathEqualTo(path) || shouldReplaceUrl) {\n                this.location.replaceState(path);\n              } else {\n                this.location.go(path);\n              }\n            }\n\n            new ActivateRoutes(this.routeReuseStrategy, state, storedState)\n                .activate(this.rootContexts);\n\n            navigationIsSuccessful = true;\n          })\n          .then(\n              () => {\n                if (navigationIsSuccessful) {\n                  this.navigated = true;\n                  this.routerEvents.next(new NavigationEnd(\n                      id, this.serializeUrl(url), this.serializeUrl(this.currentUrlTree)));\n                  resolvePromise(true);\n                } else {\n                  this.resetUrlToCurrentUrlTree();\n                  this.routerEvents.next(new NavigationCancel(id, this.serializeUrl(url), ''));\n                  resolvePromise(false);\n                }\n              },\n              (e: any) => {\n                if (isNavigationCancelingError(e)) {\n                  this.resetUrlToCurrentUrlTree();\n                  this.navigated = true;\n                  this.routerEvents.next(\n                      new NavigationCancel(id, this.serializeUrl(url), e.message));\n                  resolvePromise(false);\n                } else {\n                  this.routerEvents.next(new NavigationError(id, this.serializeUrl(url), e));\n                  try {\n                    resolvePromise(this.errorHandler(e));\n                  } catch ( /** @type {?} */ee) {\n                    rejectPromise(ee);\n                  }\n                }\n\n                this.currentRouterState = storedState;\n                this.currentUrlTree = storedUrl;\n                this.rawUrlTree = this.urlHandlingStrategy.merge(this.currentUrlTree, rawUrl);\n                this.location.replaceState(this.serializeUrl(this.rawUrlTree));\n              });\n    });\n  }\n/**\n * @return {?}\n */\nprivate resetUrlToCurrentUrlTree(): void {\n    const /** @type {?} */ path = this.urlSerializer.serialize(this.rawUrlTree);\n    this.location.replaceState(path);\n  }\n}\n\nfunction Router_tsickle_Closure_declarations() {\n/** @type {?} */\nRouter.prototype.currentUrlTree;\n/** @type {?} */\nRouter.prototype.rawUrlTree;\n/** @type {?} */\nRouter.prototype.navigations;\n/** @type {?} */\nRouter.prototype.routerEvents;\n/** @type {?} */\nRouter.prototype.currentRouterState;\n/** @type {?} */\nRouter.prototype.locationSubscription;\n/** @type {?} */\nRouter.prototype.navigationId;\n/** @type {?} */\nRouter.prototype.configLoader;\n/** @type {?} */\nRouter.prototype.ngModule;\n/**\n * Error handler that is invoked when a navigation errors.\n * \n * See {\\@link ErrorHandler} for more information.\n * @type {?}\n */\nRouter.prototype.errorHandler;\n/**\n * Indicates if at least one navigation happened.\n * @type {?}\n */\nRouter.prototype.navigated;\n/**\n * Used by RouterModule. This allows us to\n * pause the navigation either before preactivation or after it.\n * \\@internal\n * @type {?}\n */\nRouter.prototype.hooks;\n/**\n * Extracts and merges URLs. Used for AngularJS to Angular migrations.\n * @type {?}\n */\nRouter.prototype.urlHandlingStrategy;\n/** @type {?} */\nRouter.prototype.routeReuseStrategy;\n/** @type {?} */\nRouter.prototype.rootComponentType;\n/** @type {?} */\nRouter.prototype.urlSerializer;\n/** @type {?} */\nRouter.prototype.rootContexts;\n/** @type {?} */\nRouter.prototype.location;\n/** @type {?} */\nRouter.prototype.config;\n}\n\nclass CanActivate {\n/**\n * @param {?} path\n */\nconstructor(public path: ActivatedRouteSnapshot[]) {}\n/**\n * @return {?}\n */\nget route(): ActivatedRouteSnapshot { return this.path[this.path.length - 1]; }\n}\n\nfunction CanActivate_tsickle_Closure_declarations() {\n/** @type {?} */\nCanActivate.prototype.path;\n}\n\nclass CanDeactivate {\n/**\n * @param {?} component\n * @param {?} route\n */\nconstructor(public component: Object|null,\npublic route: ActivatedRouteSnapshot) {}\n}\n\nfunction CanDeactivate_tsickle_Closure_declarations() {\n/** @type {?} */\nCanDeactivate.prototype.component;\n/** @type {?} */\nCanDeactivate.prototype.route;\n}\n\nexport class PreActivation {\nprivate canActivateChecks: CanActivate[] = [];\nprivate canDeactivateChecks: CanDeactivate[] = [];\n/**\n * @param {?} future\n * @param {?} curr\n * @param {?} moduleInjector\n */\nconstructor(\nprivate future: RouterStateSnapshot,\nprivate curr: RouterStateSnapshot,\nprivate moduleInjector: Injector) {}\n/**\n * @param {?} parentContexts\n * @return {?}\n */\ntraverse(parentContexts: ChildrenOutletContexts): void {\n    const /** @type {?} */ futureRoot = this.future._root;\n    const /** @type {?} */ currRoot = this.curr ? this.curr._root : null;\n    this.traverseChildRoutes(futureRoot, currRoot, parentContexts, [futureRoot.value]);\n  }\n/**\n * @return {?}\n */\ncheckGuards(): Observable<boolean> {\n    if (!this.isDeactivating() && !this.isActivating()) {\n      return of (true);\n    }\n    const /** @type {?} */ canDeactivate$ = this.runCanDeactivateChecks();\n    return mergeMap.call(\n        canDeactivate$,\n        (canDeactivate: boolean) => canDeactivate ? this.runCanActivateChecks() : of (false));\n  }\n/**\n * @return {?}\n */\nresolveData(): Observable<any> {\n    if (!this.isActivating()) return of (null);\n    const /** @type {?} */ checks$ = from(this.canActivateChecks);\n    const /** @type {?} */ runningChecks$ =\n        concatMap.call(checks$, (check: CanActivate) => this.runResolve(check.route));\n    return reduce.call(runningChecks$, (_: any, __: any) => _);\n  }\n/**\n * @return {?}\n */\nisDeactivating(): boolean { return this.canDeactivateChecks.length !== 0; }\n/**\n * @return {?}\n */\nisActivating(): boolean { return this.canActivateChecks.length !== 0; }\n/**\n * @param {?} futureNode\n * @param {?} currNode\n * @param {?} contexts\n * @param {?} futurePath\n * @return {?}\n */\nprivate traverseChildRoutes(\n      futureNode: TreeNode<ActivatedRouteSnapshot>, currNode: TreeNode<ActivatedRouteSnapshot>|null,\n      contexts: ChildrenOutletContexts|null, futurePath: ActivatedRouteSnapshot[]): void {\n    const /** @type {?} */ prevChildren = nodeChildrenAsMap(currNode);\n\n    // Process the children of the future route\n    futureNode.children.forEach(c => {\n      this.traverseRoutes(c, prevChildren[c.value.outlet], contexts, futurePath.concat([c.value]));\n      delete prevChildren[c.value.outlet];\n    });\n\n    // Process any children left from the current route (not active for the future route)\n    forEach(\n        prevChildren, (v: TreeNode<ActivatedRouteSnapshot>, k: string) =>\n                          this.deactivateRouteAndItsChildren(v, /** @type {?} */(( contexts)).getContext(k)));\n  }\n/**\n * @param {?} futureNode\n * @param {?} currNode\n * @param {?} parentContexts\n * @param {?} futurePath\n * @return {?}\n */\nprivate traverseRoutes(\n      futureNode: TreeNode<ActivatedRouteSnapshot>, currNode: TreeNode<ActivatedRouteSnapshot>,\n      parentContexts: ChildrenOutletContexts|null, futurePath: ActivatedRouteSnapshot[]): void {\n    const /** @type {?} */ future = futureNode.value;\n    const /** @type {?} */ curr = currNode ? currNode.value : null;\n    const /** @type {?} */ context = parentContexts ? parentContexts.getContext(futureNode.value.outlet) : null;\n\n    // reusing the node\n    if (curr && future._routeConfig === curr._routeConfig) {\n      const /** @type {?} */ shouldRunGuardsAndResolvers = this.shouldRunGuardsAndResolvers(\n          curr, future, /** @type {?} */(( future._routeConfig)).runGuardsAndResolvers);\n      if (shouldRunGuardsAndResolvers) {\n        this.canActivateChecks.push(new CanActivate(futurePath));\n      } else {\n        // we need to set the data\n        future.data = curr.data;\n        future._resolvedData = curr._resolvedData;\n      }\n\n      // If we have a component, we need to go through an outlet.\n      if (future.component) {\n        this.traverseChildRoutes(\n            futureNode, currNode, context ? context.children : null, futurePath);\n\n        // if we have a componentless route, we recurse but keep the same outlet map.\n      } else {\n        this.traverseChildRoutes(futureNode, currNode, parentContexts, futurePath);\n      }\n\n      if (shouldRunGuardsAndResolvers) {\n        const /** @type {?} */ outlet = /** @type {?} */(( /** @type {?} */(( context)).outlet));\n        this.canDeactivateChecks.push(new CanDeactivate(outlet.component, curr));\n      }\n    } else {\n      if (curr) {\n        this.deactivateRouteAndItsChildren(currNode, context);\n      }\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.traverseChildRoutes(futureNode, null, context ? context.children : null, futurePath);\n\n        // if we have a componentless route, we recurse but keep the same outlet map.\n      } else {\n        this.traverseChildRoutes(futureNode, null, parentContexts, futurePath);\n      }\n    }\n  }\n/**\n * @param {?} curr\n * @param {?} future\n * @param {?} mode\n * @return {?}\n */\nprivate shouldRunGuardsAndResolvers(\n      curr: ActivatedRouteSnapshot, future: ActivatedRouteSnapshot,\n      mode: RunGuardsAndResolvers|undefined): boolean {\n    switch (mode) {\n      case 'always':\n        return true;\n\n      case 'paramsOrQueryParamsChange':\n        return !equalParamsAndUrlSegments(curr, future) ||\n            !shallowEqual(curr.queryParams, future.queryParams);\n\n      case 'paramsChange':\n      default:\n        return !equalParamsAndUrlSegments(curr, future);\n    }\n  }\n/**\n * @param {?} route\n * @param {?} context\n * @return {?}\n */\nprivate deactivateRouteAndItsChildren(\n      route: TreeNode<ActivatedRouteSnapshot>, context: OutletContext|null): void {\n    const /** @type {?} */ children = nodeChildrenAsMap(route);\n    const /** @type {?} */ r = route.value;\n\n    forEach(children, (node: TreeNode<ActivatedRouteSnapshot>, childName: string) => {\n      if (!r.component) {\n        this.deactivateRouteAndItsChildren(node, context);\n      } else if (context) {\n        this.deactivateRouteAndItsChildren(node, context.children.getContext(childName));\n      } else {\n        this.deactivateRouteAndItsChildren(node, null);\n      }\n    });\n\n    if (!r.component) {\n      this.canDeactivateChecks.push(new CanDeactivate(null, r));\n    } else if (context && context.outlet && context.outlet.isActivated) {\n      this.canDeactivateChecks.push(new CanDeactivate(context.outlet.component, r));\n    } else {\n      this.canDeactivateChecks.push(new CanDeactivate(null, r));\n    }\n  }\n/**\n * @return {?}\n */\nprivate runCanDeactivateChecks(): Observable<boolean> {\n    const /** @type {?} */ checks$ = from(this.canDeactivateChecks);\n    const /** @type {?} */ runningChecks$ = mergeMap.call(\n        checks$, (check: CanDeactivate) => this.runCanDeactivate(check.component, check.route));\n    return every.call(runningChecks$, (result: boolean) => result === true);\n  }\n/**\n * @return {?}\n */\nprivate runCanActivateChecks(): Observable<boolean> {\n    const /** @type {?} */ checks$ = from(this.canActivateChecks);\n    const /** @type {?} */ runningChecks$ = concatMap.call(\n        checks$, (check: CanActivate) => andObservables(from(\n                     [this.runCanActivateChild(check.path), this.runCanActivate(check.route)])));\n    return every.call(runningChecks$, (result: boolean) => result === true);\n  }\n/**\n * @param {?} future\n * @return {?}\n */\nprivate runCanActivate(future: ActivatedRouteSnapshot): Observable<boolean> {\n    const /** @type {?} */ canActivate = future._routeConfig ? future._routeConfig.canActivate : null;\n    if (!canActivate || canActivate.length === 0) return of (true);\n    const /** @type {?} */ obs = map.call(from(canActivate), (c: any) => {\n      const /** @type {?} */ guard = this.getToken(c, future);\n      let /** @type {?} */ observable: Observable<boolean>;\n      if (guard.canActivate) {\n        observable = wrapIntoObservable(guard.canActivate(future, this.future));\n      } else {\n        observable = wrapIntoObservable(guard(future, this.future));\n      }\n      return first.call(observable);\n    });\n    return andObservables(obs);\n  }\n/**\n * @param {?} path\n * @return {?}\n */\nprivate runCanActivateChild(path: ActivatedRouteSnapshot[]): Observable<boolean> {\n    const /** @type {?} */ future = path[path.length - 1];\n\n    const /** @type {?} */ canActivateChildGuards = path.slice(0, path.length - 1)\n                                       .reverse()\n                                       .map(p => this.extractCanActivateChild(p))\n                                       .filter(_ => _ !== null);\n\n    return andObservables(map.call(from(canActivateChildGuards), (d: any) => {\n      const /** @type {?} */ obs = map.call(from(d.guards), (c: any) => {\n        const /** @type {?} */ guard = this.getToken(c, d.node);\n        let /** @type {?} */ observable: Observable<boolean>;\n        if (guard.canActivateChild) {\n          observable = wrapIntoObservable(guard.canActivateChild(future, this.future));\n        } else {\n          observable = wrapIntoObservable(guard(future, this.future));\n        }\n        return first.call(observable);\n      });\n      return andObservables(obs);\n    }));\n  }\n/**\n * @param {?} p\n * @return {?}\n */\nprivate extractCanActivateChild(p: ActivatedRouteSnapshot):\n      {node: ActivatedRouteSnapshot, guards: any[]}|null {\n    const /** @type {?} */ canActivateChild = p._routeConfig ? p._routeConfig.canActivateChild : null;\n    if (!canActivateChild || canActivateChild.length === 0) return null;\n    return {node: p, guards: canActivateChild};\n  }\n/**\n * @param {?} component\n * @param {?} curr\n * @return {?}\n */\nprivate runCanDeactivate(component: Object|null, curr: ActivatedRouteSnapshot):\n      Observable<boolean> {\n    const /** @type {?} */ canDeactivate = curr && curr._routeConfig ? curr._routeConfig.canDeactivate : null;\n    if (!canDeactivate || canDeactivate.length === 0) return of (true);\n    const /** @type {?} */ canDeactivate$ = mergeMap.call(from(canDeactivate), (c: any) => {\n      const /** @type {?} */ guard = this.getToken(c, curr);\n      let /** @type {?} */ observable: Observable<boolean>;\n      if (guard.canDeactivate) {\n        observable =\n            wrapIntoObservable(guard.canDeactivate(component, curr, this.curr, this.future));\n      } else {\n        observable = wrapIntoObservable(guard(component, curr, this.curr, this.future));\n      }\n      return first.call(observable);\n    });\n    return every.call(canDeactivate$, (result: any) => result === true);\n  }\n/**\n * @param {?} future\n * @return {?}\n */\nprivate runResolve(future: ActivatedRouteSnapshot): Observable<any> {\n    const /** @type {?} */ resolve = future._resolve;\n    return map.call(this.resolveNode(resolve, future), (resolvedData: any): any => {\n      future._resolvedData = resolvedData;\n      future.data = {...future.data, ...inheritedParamsDataResolve(future).resolve};\n      return null;\n    });\n  }\n/**\n * @param {?} resolve\n * @param {?} future\n * @return {?}\n */\nprivate resolveNode(resolve: ResolveData, future: ActivatedRouteSnapshot): Observable<any> {\n    const /** @type {?} */ keys = Object.keys(resolve);\n    if (keys.length === 0) {\n      return of ({});\n    }\n    if (keys.length === 1) {\n      const /** @type {?} */ key = keys[0];\n      return map.call(\n          this.getResolver(resolve[key], future), (value: any) => { return {[key]: value}; });\n    }\n    const /** @type {?} */ data: {[k: string]: any} = {};\n    const /** @type {?} */ runningResolvers$ = mergeMap.call(from(keys), (key: string) => {\n      return map.call(this.getResolver(resolve[key], future), (value: any) => {\n        data[key] = value;\n        return value;\n      });\n    });\n    return map.call(last.call(runningResolvers$), () => data);\n  }\n/**\n * @param {?} injectionToken\n * @param {?} future\n * @return {?}\n */\nprivate getResolver(injectionToken: any, future: ActivatedRouteSnapshot): Observable<any> {\n    const /** @type {?} */ resolver = this.getToken(injectionToken, future);\n    return resolver.resolve ? wrapIntoObservable(resolver.resolve(future, this.future)) :\n                              wrapIntoObservable(resolver(future, this.future));\n  }\n/**\n * @param {?} token\n * @param {?} snapshot\n * @return {?}\n */\nprivate getToken(token: any, snapshot: ActivatedRouteSnapshot): any {\n    const /** @type {?} */ config = closestLoadedConfig(snapshot);\n    const /** @type {?} */ injector = config ? config.module.injector : this.moduleInjector;\n    return injector.get(token);\n  }\n}\n\nfunction PreActivation_tsickle_Closure_declarations() {\n/** @type {?} */\nPreActivation.prototype.canActivateChecks;\n/** @type {?} */\nPreActivation.prototype.canDeactivateChecks;\n/** @type {?} */\nPreActivation.prototype.future;\n/** @type {?} */\nPreActivation.prototype.curr;\n/** @type {?} */\nPreActivation.prototype.moduleInjector;\n}\n\nclass ActivateRoutes {\n/**\n * @param {?} routeReuseStrategy\n * @param {?} futureState\n * @param {?} currState\n */\nconstructor(\nprivate routeReuseStrategy: RouteReuseStrategy,\nprivate futureState: RouterState,\nprivate currState: RouterState) {}\n/**\n * @param {?} parentContexts\n * @return {?}\n */\nactivate(parentContexts: ChildrenOutletContexts): void {\n    const /** @type {?} */ futureRoot = this.futureState._root;\n    const /** @type {?} */ currRoot = this.currState ? this.currState._root : null;\n\n    this.deactivateChildRoutes(futureRoot, currRoot, parentContexts);\n    advanceActivatedRoute(this.futureState.root);\n    this.activateChildRoutes(futureRoot, currRoot, parentContexts);\n  }\n/**\n * @param {?} futureNode\n * @param {?} currNode\n * @param {?} contexts\n * @return {?}\n */\nprivate deactivateChildRoutes(\n      futureNode: TreeNode<ActivatedRoute>, currNode: TreeNode<ActivatedRoute>|null,\n      contexts: ChildrenOutletContexts): void {\n    const /** @type {?} */ children: {[outletName: string]: TreeNode<ActivatedRoute>} = nodeChildrenAsMap(currNode);\n\n    // Recurse on the routes active in the future state to de-activate deeper children\n    futureNode.children.forEach(futureChild => {\n      const /** @type {?} */ childOutletName = futureChild.value.outlet;\n      this.deactivateRoutes(futureChild, children[childOutletName], contexts);\n      delete children[childOutletName];\n    });\n\n    // De-activate the routes that will not be re-used\n    forEach(children, (v: TreeNode<ActivatedRoute>, childName: string) => {\n      this.deactivateRouteAndItsChildren(v, contexts);\n    });\n  }\n/**\n * @param {?} futureNode\n * @param {?} currNode\n * @param {?} parentContext\n * @return {?}\n */\nprivate deactivateRoutes(\n      futureNode: TreeNode<ActivatedRoute>, currNode: TreeNode<ActivatedRoute>,\n      parentContext: ChildrenOutletContexts): void {\n    const /** @type {?} */ future = futureNode.value;\n    const /** @type {?} */ curr = currNode ? currNode.value : null;\n\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        const /** @type {?} */ context = parentContext.getContext(future.outlet);\n        if (context) {\n          this.deactivateChildRoutes(futureNode, currNode, context.children);\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    } else {\n      if (curr) {\n        // Deactivate the current route which will not be re-used\n        this.deactivateRouteAndItsChildren(currNode, parentContext);\n      }\n    }\n  }\n/**\n * @param {?} route\n * @param {?} parentContexts\n * @return {?}\n */\nprivate deactivateRouteAndItsChildren(\n      route: TreeNode<ActivatedRoute>, parentContexts: ChildrenOutletContexts): void {\n    if (this.routeReuseStrategy.shouldDetach(route.value.snapshot)) {\n      this.detachAndStoreRouteSubtree(route, parentContexts);\n    } else {\n      this.deactivateRouteAndOutlet(route, parentContexts);\n    }\n  }\n/**\n * @param {?} route\n * @param {?} parentContexts\n * @return {?}\n */\nprivate detachAndStoreRouteSubtree(\n      route: TreeNode<ActivatedRoute>, parentContexts: ChildrenOutletContexts): void {\n    const /** @type {?} */ context = parentContexts.getContext(route.value.outlet);\n    if (context && context.outlet) {\n      const /** @type {?} */ componentRef = context.outlet.detach();\n      const /** @type {?} */ contexts = context.children.onOutletDeactivated();\n      this.routeReuseStrategy.store(route.value.snapshot, {componentRef, route, contexts});\n    }\n  }\n/**\n * @param {?} route\n * @param {?} parentContexts\n * @return {?}\n */\nprivate deactivateRouteAndOutlet(\n      route: TreeNode<ActivatedRoute>, parentContexts: ChildrenOutletContexts): void {\n    const /** @type {?} */ context = parentContexts.getContext(route.value.outlet);\n\n    if (context) {\n      const /** @type {?} */ children: {[outletName: string]: any} = nodeChildrenAsMap(route);\n      const /** @type {?} */ contexts = route.value.component ? context.children : parentContexts;\n\n      forEach(children, (v: any, k: string) => this.deactivateRouteAndItsChildren(v, contexts));\n\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/**\n * @param {?} futureNode\n * @param {?} currNode\n * @param {?} contexts\n * @return {?}\n */\nprivate activateChildRoutes(\n      futureNode: TreeNode<ActivatedRoute>, currNode: TreeNode<ActivatedRoute>|null,\n      contexts: ChildrenOutletContexts): void {\n    const /** @type {?} */ children: {[outlet: string]: any} = nodeChildrenAsMap(currNode);\n    futureNode.children.forEach(\n        c => { this.activateRoutes(c, children[c.value.outlet], contexts); });\n  }\n/**\n * @param {?} futureNode\n * @param {?} currNode\n * @param {?} parentContexts\n * @return {?}\n */\nprivate activateRoutes(\n      futureNode: TreeNode<ActivatedRoute>, currNode: TreeNode<ActivatedRoute>,\n      parentContexts: ChildrenOutletContexts): void {\n    const /** @type {?} */ future = futureNode.value;\n    const /** @type {?} */ curr = currNode ? currNode.value : null;\n\n    advanceActivatedRoute(future);\n\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        const /** @type {?} */ context = parentContexts.getOrCreateContext(future.outlet);\n        this.activateChildRoutes(futureNode, currNode, context.children);\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    } else {\n      if (future.component) {\n        // if we have a normal route, we need to place the component into the outlet and recurse.\n        const /** @type {?} */ context = parentContexts.getOrCreateContext(future.outlet);\n\n        if (this.routeReuseStrategy.shouldAttach(future.snapshot)) {\n          const /** @type {?} */ stored =\n              ( /** @type {?} */((<DetachedRouteHandleInternal>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        } else {\n          const /** @type {?} */ config = parentLoadedConfig(future.snapshot);\n          const /** @type {?} */ cmpFactoryResolver = config ? config.module.componentFactoryResolver : null;\n\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\n          this.activateChildRoutes(futureNode, null, context.children);\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}\n\nfunction ActivateRoutes_tsickle_Closure_declarations() {\n/** @type {?} */\nActivateRoutes.prototype.routeReuseStrategy;\n/** @type {?} */\nActivateRoutes.prototype.futureState;\n/** @type {?} */\nActivateRoutes.prototype.currState;\n}\n\n/**\n * @param {?} node\n * @return {?}\n */\nfunction advanceActivatedRouteNodeAndItsChildren(node: TreeNode<ActivatedRoute>): void {\n  advanceActivatedRoute(node.value);\n  node.children.forEach(advanceActivatedRouteNodeAndItsChildren);\n}\n/**\n * @param {?} snapshot\n * @return {?}\n */\nfunction parentLoadedConfig(snapshot: ActivatedRouteSnapshot): LoadedRouterConfig|null {\n  for (let /** @type {?} */ s = snapshot.parent; s; s = s.parent) {\n    const /** @type {?} */ route = s._routeConfig;\n    if (route && route._loadedConfig) return route._loadedConfig;\n    if (route && route.component) return null;\n  }\n\n  return null;\n}\n/**\n * @param {?} snapshot\n * @return {?}\n */\nfunction closestLoadedConfig(snapshot: ActivatedRouteSnapshot): LoadedRouterConfig|null {\n  if (!snapshot) return null;\n\n  for (let /** @type {?} */ s = snapshot.parent; s; s = s.parent) {\n    const /** @type {?} */ route = s._routeConfig;\n    if (route && route._loadedConfig) return route._loadedConfig;\n  }\n\n  return null;\n}\n/**\n * @template T\n * @param {?} node\n * @return {?}\n */\nfunction nodeChildrenAsMap<T extends{outlet: string}>(node: TreeNode<T>| null) {\n  const /** @type {?} */ map: {[outlet: string]: TreeNode<T>} = {};\n\n  if (node) {\n    node.children.forEach(child => map[child.value.outlet] = child);\n  }\n\n  return map;\n}\n/**\n * @param {?} commands\n * @return {?}\n */\nfunction validateCommands(commands: string[]): void {\n  for (let /** @type {?} */ i = 0; i < commands.length; i++) {\n    const /** @type {?} */ 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 * @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 * @module\n * @description\n * Entry point for all public APIs of the common package.\n */\n\n\nimport {Version} from '@angular/core';\n/**\n * \\@stable\n */\nexport const VERSION = new Version('4.4.6');\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = Object.setPrototypeOf ||\r\n    ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n    function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = Object.assign || function __assign(t) {\r\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n        s = arguments[i];\r\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n    }\r\n    return t;\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [0, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);  }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { if (o[n]) i[n] = function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; }; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator];\r\n    return m ? m.call(o) : typeof __values === \"function\" ? __values(o) : o[Symbol.iterator]();\r\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\nimport {Route} from './config';\nimport {RouterStateSnapshot} from './router_state';\n/**\n * \\@whatItDoes Represents an event triggered when a navigation starts.\n * \n * \\@stable\n */\nexport class NavigationStart {\n/**\n * @param {?} id\n * @param {?} url\n */\nconstructor(\npublic id: number,\npublic url: string) {}\n/**\n * \\@docsNotRequired\n * @return {?}\n */\ntoString(): string { return `NavigationStart(id: ${this.id}, url: '${this.url}')`; }\n}\n\nfunction NavigationStart_tsickle_Closure_declarations() {\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nNavigationStart.prototype.id;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nNavigationStart.prototype.url;\n}\n\n/**\n * \\@whatItDoes Represents an event triggered when a navigation ends successfully.\n * \n * \\@stable\n */\nexport class NavigationEnd {\n/**\n * @param {?} id\n * @param {?} url\n * @param {?} urlAfterRedirects\n */\nconstructor(\npublic id: number,\npublic url: string,\npublic urlAfterRedirects: string) {}\n/**\n * \\@docsNotRequired\n * @return {?}\n */\ntoString(): string {\n    return `NavigationEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}')`;\n  }\n}\n\nfunction NavigationEnd_tsickle_Closure_declarations() {\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nNavigationEnd.prototype.id;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nNavigationEnd.prototype.url;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nNavigationEnd.prototype.urlAfterRedirects;\n}\n\n/**\n * \\@whatItDoes Represents an event triggered when a navigation is canceled.\n * \n * \\@stable\n */\nexport class NavigationCancel {\n/**\n * @param {?} id\n * @param {?} url\n * @param {?} reason\n */\nconstructor(\npublic id: number,\npublic url: string,\npublic reason: string) {}\n/**\n * \\@docsNotRequired\n * @return {?}\n */\ntoString(): string { return `NavigationCancel(id: ${this.id}, url: '${this.url}')`; }\n}\n\nfunction NavigationCancel_tsickle_Closure_declarations() {\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nNavigationCancel.prototype.id;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nNavigationCancel.prototype.url;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nNavigationCancel.prototype.reason;\n}\n\n/**\n * \\@whatItDoes Represents an event triggered when a navigation fails due to an unexpected error.\n * \n * \\@stable\n */\nexport class NavigationError {\n/**\n * @param {?} id\n * @param {?} url\n * @param {?} error\n */\nconstructor(\npublic id: number,\npublic url: string,\npublic error: any) {}\n/**\n * \\@docsNotRequired\n * @return {?}\n */\ntoString(): string {\n    return `NavigationError(id: ${this.id}, url: '${this.url}', error: ${this.error})`;\n  }\n}\n\nfunction NavigationError_tsickle_Closure_declarations() {\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nNavigationError.prototype.id;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nNavigationError.prototype.url;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nNavigationError.prototype.error;\n}\n\n/**\n * \\@whatItDoes Represents an event triggered when routes are recognized.\n * \n * \\@stable\n */\nexport class RoutesRecognized {\n/**\n * @param {?} id\n * @param {?} url\n * @param {?} urlAfterRedirects\n * @param {?} state\n */\nconstructor(\npublic id: number,\npublic url: string,\npublic urlAfterRedirects: string,\npublic state: RouterStateSnapshot) {}\n/**\n * \\@docsNotRequired\n * @return {?}\n */\ntoString(): string {\n    return `RoutesRecognized(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;\n  }\n}\n\nfunction RoutesRecognized_tsickle_Closure_declarations() {\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nRoutesRecognized.prototype.id;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nRoutesRecognized.prototype.url;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nRoutesRecognized.prototype.urlAfterRedirects;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nRoutesRecognized.prototype.state;\n}\n\n/**\n * \\@whatItDoes Represents an event triggered before lazy loading a route config.\n * \n * \\@experimental\n */\nexport class RouteConfigLoadStart {\n/**\n * @param {?} route\n */\nconstructor(public route: Route) {}\n/**\n * @return {?}\n */\ntoString(): string { return `RouteConfigLoadStart(path: ${this.route.path})`; }\n}\n\nfunction RouteConfigLoadStart_tsickle_Closure_declarations() {\n/** @type {?} */\nRouteConfigLoadStart.prototype.route;\n}\n\n/**\n * \\@whatItDoes Represents an event triggered when a route has been lazy loaded.\n * \n * \\@experimental\n */\nexport class RouteConfigLoadEnd {\n/**\n * @param {?} route\n */\nconstructor(public route: Route) {}\n/**\n * @return {?}\n */\ntoString(): string { return `RouteConfigLoadEnd(path: ${this.route.path})`; }\n}\n\nfunction RouteConfigLoadEnd_tsickle_Closure_declarations() {\n/** @type {?} */\nRouteConfigLoadEnd.prototype.route;\n}\n\n/**\n * \\@whatItDoes Represents the start of the Guard phase of routing.\n * \n * \\@experimental\n */\nexport class GuardsCheckStart {\n/**\n * @param {?} id\n * @param {?} url\n * @param {?} urlAfterRedirects\n * @param {?} state\n */\nconstructor(\npublic id: number,\npublic url: string,\npublic urlAfterRedirects: string,\npublic state: RouterStateSnapshot) {}\n/**\n * @return {?}\n */\ntoString(): string {\n    return `GuardsCheckStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;\n  }\n}\n\nfunction GuardsCheckStart_tsickle_Closure_declarations() {\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nGuardsCheckStart.prototype.id;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nGuardsCheckStart.prototype.url;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nGuardsCheckStart.prototype.urlAfterRedirects;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nGuardsCheckStart.prototype.state;\n}\n\n/**\n * \\@whatItDoes Represents the end of the Guard phase of routing.\n * \n * \\@experimental\n */\nexport class GuardsCheckEnd {\n/**\n * @param {?} id\n * @param {?} url\n * @param {?} urlAfterRedirects\n * @param {?} state\n * @param {?} shouldActivate\n */\nconstructor(\npublic id: number,\npublic url: string,\npublic urlAfterRedirects: string,\npublic state: RouterStateSnapshot,\npublic shouldActivate: boolean) {}\n/**\n * @return {?}\n */\ntoString(): string {\n    return `GuardsCheckEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state}, shouldActivate: ${this.shouldActivate})`;\n  }\n}\n\nfunction GuardsCheckEnd_tsickle_Closure_declarations() {\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nGuardsCheckEnd.prototype.id;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nGuardsCheckEnd.prototype.url;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nGuardsCheckEnd.prototype.urlAfterRedirects;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nGuardsCheckEnd.prototype.state;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nGuardsCheckEnd.prototype.shouldActivate;\n}\n\n/**\n * \\@whatItDoes 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 */\nexport class ResolveStart {\n/**\n * @param {?} id\n * @param {?} url\n * @param {?} urlAfterRedirects\n * @param {?} state\n */\nconstructor(\npublic id: number,\npublic url: string,\npublic urlAfterRedirects: string,\npublic state: RouterStateSnapshot) {}\n/**\n * @return {?}\n */\ntoString(): string {\n    return `ResolveStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;\n  }\n}\n\nfunction ResolveStart_tsickle_Closure_declarations() {\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nResolveStart.prototype.id;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nResolveStart.prototype.url;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nResolveStart.prototype.urlAfterRedirects;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nResolveStart.prototype.state;\n}\n\n/**\n * \\@whatItDoes Represents the end of the Resolve phase of routing. See note on\n * {\\@link ResolveStart} for use of this experimental API.\n * \n * \\@experimental\n */\nexport class ResolveEnd {\n/**\n * @param {?} id\n * @param {?} url\n * @param {?} urlAfterRedirects\n * @param {?} state\n */\nconstructor(\npublic id: number,\npublic url: string,\npublic urlAfterRedirects: string,\npublic state: RouterStateSnapshot) {}\n/**\n * @return {?}\n */\ntoString(): string {\n    return `ResolveEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;\n  }\n}\n\nfunction ResolveEnd_tsickle_Closure_declarations() {\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nResolveEnd.prototype.id;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nResolveEnd.prototype.url;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nResolveEnd.prototype.urlAfterRedirects;\n/**\n * \\@docsNotRequired\n * @type {?}\n */\nResolveEnd.prototype.state;\n}\n\n\n/**\n * @whatItDoes Represents a router event, allowing you to track the lifecycle of the router.\n *\n * The sequence of router events is:\n *\n * - {@link NavigationStart},\n * - {@link RouteConfigLoadStart},\n * - {@link RouteConfigLoadEnd},\n * - {@link RoutesRecognized},\n * - {@link GuardsCheckStart},\n * - {@link GuardsCheckEnd},\n * - {@link ResolveStart},\n * - {@link ResolveEnd},\n * - {@link NavigationEnd},\n * - {@link NavigationCancel},\n * - {@link NavigationError}\n *\n * @stable\n */\nexport type Event = NavigationStart | NavigationEnd | NavigationCancel | NavigationError |\n    RoutesRecognized | RouteConfigLoadStart | RouteConfigLoadEnd | GuardsCheckStart |\n    GuardsCheckEnd | ResolveStart | ResolveEnd;\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\nimport {Route, UrlMatchResult} from './config';\nimport {UrlSegment, UrlSegmentGroup} from './url_tree';\n/**\n * \\@whatItDoes Name of the primary outlet.\n * \n * \\@stable\n */\nexport const PRIMARY_OUTLET = 'primary';\n\n/**\n * A collection of parameters.\n *\n * @stable\n */\nexport type Params = {\n  [key: string]: any\n};\n\n/**\n * Matrix and Query parameters.\n *\n * `ParamMap` makes it easier to work with parameters as they could have either a single value or\n * multiple value. Because this should be known by the user, calling `get` or `getAll` returns the\n * correct type (either `string` or `string[]`).\n *\n * The API is inspired by the URLSearchParams interface.\n * see https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams\n *\n * @stable\n */\nexport interface ParamMap {\n  has(name: string): boolean;\n  /**\n   * Return a single value for the given parameter name:\n   * - the value when the parameter has a single value,\n   * - the first value if the parameter has multiple values,\n   * - `null` when there is no such parameter.\n   */\n  get(name: string): string|null;\n  /**\n   * Return an array of values for the given parameter name.\n   *\n   * If there is no such parameter, an empty array is returned.\n   */\n  getAll(name: string): string[];\n\n  /** Name of the parameters */\n  readonly keys: string[];\n}\nclass ParamsAsMap implements ParamMap {\nprivate params: Params;\n/**\n * @param {?} params\n */\nconstructor(params: Params) { this.params = params || {}; }\n/**\n * @param {?} name\n * @return {?}\n */\nhas(name: string): boolean { return this.params.hasOwnProperty(name); }\n/**\n * @param {?} name\n * @return {?}\n */\nget(name: string): string|null {\n    if (this.has(name)) {\n      const /** @type {?} */ v = this.params[name];\n      return Array.isArray(v) ? v[0] : v;\n    }\n\n    return null;\n  }\n/**\n * @param {?} name\n * @return {?}\n */\ngetAll(name: string): string[] {\n    if (this.has(name)) {\n      const /** @type {?} */ v = this.params[name];\n      return Array.isArray(v) ? v : [v];\n    }\n\n    return [];\n  }\n/**\n * @return {?}\n */\nget keys(): string[] { return Object.keys(this.params); }\n}\n\nfunction ParamsAsMap_tsickle_Closure_declarations() {\n/** @type {?} */\nParamsAsMap.prototype.params;\n}\n\n/**\n * Convert a {\\@link Params} instance to a {\\@link ParamMap}.\n * \n * \\@stable\n * @param {?} params\n * @return {?}\n */\nexport function convertToParamMap(params: Params): ParamMap {\n  return new ParamsAsMap(params);\n}\n\nconst /** @type {?} */ NAVIGATION_CANCELING_ERROR = 'ngNavigationCancelingError';\n/**\n * @param {?} message\n * @return {?}\n */\nexport function navigationCancelingError(message: string) {\n  const /** @type {?} */ error = Error('NavigationCancelingError: ' + message);\n  ( /** @type {?} */((error as any)))[NAVIGATION_CANCELING_ERROR] = true;\n  return error;\n}\n/**\n * @param {?} error\n * @return {?}\n */\nexport function isNavigationCancelingError(error: Error) {\n  return ( /** @type {?} */((error as any)))[NAVIGATION_CANCELING_ERROR];\n}\n/**\n * @param {?} segments\n * @param {?} segmentGroup\n * @param {?} route\n * @return {?}\n */\nexport function defaultUrlMatcher(\n    segments: UrlSegment[], segmentGroup: UrlSegmentGroup, route: Route): UrlMatchResult|null {\n  const /** @type {?} */ parts = /** @type {?} */(( route.path)).split('/');\n\n  if (parts.length > segments.length) {\n    // The actual URL is shorter than the config, no match\n    return null;\n  }\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\n  const /** @type {?} */ posParams: {[key: string]: UrlSegment} = {};\n\n  // Check each config part against the actual URL\n  for (let /** @type {?} */ index = 0; index < parts.length; index++) {\n    const /** @type {?} */ part = parts[index];\n    const /** @type {?} */ segment = segments[index];\n    const /** @type {?} */ isParameter = part.startsWith(':');\n    if (isParameter) {\n      posParams[part.substring(1)] = segment;\n    } else if (part !== segment.path) {\n      // The actual URL part does not match the config, no match\n      return null;\n    }\n  }\n\n  return {consumed: segments.slice(0, parts.length), posParams};\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\nimport {NgModuleFactory, NgModuleRef, Type} from '@angular/core';\nimport {Observable} from 'rxjs/Observable';\nimport {PRIMARY_OUTLET} from './shared';\nimport {UrlSegment, UrlSegmentGroup} from './url_tree';\n\n/**\n * @whatItDoes Represents router configuration.\n *\n * @description\n * `Routes` is an array of route configurations. Each one has the following properties:\n *\n * - `path` is a string that uses the route matcher DSL.\n * - `pathMatch` is a string that specifies the matching strategy.\n * - `matcher` defines a custom strategy for path matching and supersedes `path` and `pathMatch`.\n * - `component` is a component type.\n * - `redirectTo` is the url fragment which will replace the current matched segment.\n * - `outlet` is the name of the outlet the component should be placed into.\n * - `canActivate` is an array of DI tokens used to look up CanActivate handlers. See\n *   {@link CanActivate} for more info.\n * - `canActivateChild` is an array of DI tokens used to look up CanActivateChild handlers. See\n *   {@link CanActivateChild} for more info.\n * - `canDeactivate` is an array of DI tokens used to look up CanDeactivate handlers. See\n *   {@link CanDeactivate} for more info.\n * - `canLoad` is an array of DI tokens used to look up CanLoad handlers. See\n *   {@link CanLoad} for more info.\n * - `data` is additional data provided to the component via `ActivatedRoute`.\n * - `resolve` is a map of DI tokens used to look up data resolvers. See {@link Resolve} for more\n *   info.\n * - `runGuardsAndResolvers` defines when guards and resolvers will be run. By default they run only\n *    when the matrix parameters of the route change. When set to `paramsOrQueryParamsChange` they\n *    will also run when query params change. And when set to `always`, they will run every time.\n * - `children` is an array of child route definitions.\n * - `loadChildren` is a reference to lazy loaded child routes. See {@link LoadChildren} for more\n *   info.\n *\n * ### Simple Configuration\n *\n * ```\n * [{\n *   path: 'team/:id',\n  *  component: Team,\n *   children: [{\n *     path: 'user/:name',\n *     component: User\n *   }]\n * }]\n * ```\n *\n * When navigating to `/team/11/user/bob`, the router will create the team component with the user\n * component in it.\n *\n * ### Multiple Outlets\n *\n * ```\n * [{\n *   path: 'team/:id',\n *   component: Team\n * }, {\n *   path: 'chat/:user',\n *   component: Chat\n *   outlet: 'aux'\n * }]\n * ```\n *\n * When navigating to `/team/11(aux:chat/jim)`, the router will create the team component next to\n * the chat component. The chat component will be placed into the aux outlet.\n *\n * ### Wild Cards\n *\n * ```\n * [{\n *   path: '**',\n *   component: Sink\n * }]\n * ```\n *\n * Regardless of where you navigate to, the router will instantiate the sink component.\n *\n * ### Redirects\n *\n * ```\n * [{\n *   path: 'team/:id',\n *   component: Team,\n *   children: [{\n *     path: 'legacy/user/:name',\n *     redirectTo: 'user/:name'\n *   }, {\n *     path: 'user/:name',\n *     component: User\n *   }]\n * }]\n * ```\n *\n * When navigating to '/team/11/legacy/user/jim', the router will change the url to\n * '/team/11/user/jim', and then will instantiate the team component with the user component\n * in it.\n *\n * If the `redirectTo` value starts with a '/', then it is an absolute redirect. E.g., if in the\n * example above we change the `redirectTo` to `/user/:name`, the result url will be '/user/jim'.\n *\n * ### Empty Path\n *\n * Empty-path route configurations can be used to instantiate components that do not 'consume'\n * any url segments. Let's look at the following configuration:\n *\n * ```\n * [{\n *   path: 'team/:id',\n *   component: Team,\n *   children: [{\n *     path: '',\n *     component: AllUsers\n *   }, {\n *     path: 'user/:name',\n *     component: User\n *   }]\n * }]\n * ```\n *\n * When navigating to `/team/11`, the router will instantiate the AllUsers component.\n *\n * Empty-path routes can have children.\n *\n * ```\n * [{\n *   path: 'team/:id',\n *   component: Team,\n *   children: [{\n *     path: '',\n *     component: WrapperCmp,\n *     children: [{\n *       path: 'user/:name',\n *       component: User\n *     }]\n *   }]\n * }]\n * ```\n *\n * When navigating to `/team/11/user/jim`, the router will instantiate the wrapper component with\n * the user component in it.\n *\n * An empty path route inherits its parent's params and data. This is because it cannot have its\n * own params, and, as a result, it often uses its parent's params and data as its own.\n *\n * ### Matching Strategy\n *\n * By default the router will look at what is left in the url, and check if it starts with\n * the specified path (e.g., `/team/11/user` starts with `team/:id`).\n *\n * We can change the matching strategy to make sure that the path covers the whole unconsumed url,\n * which is akin to `unconsumedUrl === path` or `$` regular expressions.\n *\n * This is particularly important when redirecting empty-path routes.\n *\n * ```\n * [{\n *   path: '',\n *   pathMatch: 'prefix', //default\n *   redirectTo: 'main'\n * }, {\n *   path: 'main',\n *   component: Main\n * }]\n * ```\n *\n * Since an empty path is a prefix of any url, even when navigating to '/main', the router will\n * still apply the redirect.\n *\n * If `pathMatch: full` is provided, the router will apply the redirect if and only if navigating to\n * '/'.\n *\n * ```\n * [{\n *   path: '',\n *   pathMatch: 'full',\n *   redirectTo: 'main'\n * }, {\n *   path: 'main',\n *   component: Main\n * }]\n * ```\n *\n * ### Componentless Routes\n *\n * It is useful at times to have the ability to share parameters between sibling components.\n *\n * Say we have two components--ChildCmp and AuxCmp--that we want to put next to each other and both\n * of them require some id parameter.\n *\n * One way to do that would be to have a bogus parent component, so both the siblings can get the id\n * parameter from it. This is not ideal. Instead, you can use a componentless route.\n *\n * ```\n * [{\n *    path: 'parent/:id',\n *    children: [\n *      { path: 'a', component: MainChild },\n *      { path: 'b', component: AuxChild, outlet: 'aux' }\n *    ]\n * }]\n * ```\n *\n * So when navigating to `parent/10/(a//aux:b)`, the route will instantiate the main child and aux\n * child components next to each other. In this example, the application component\n * has to have the primary and aux outlets defined.\n *\n * The router will also merge the `params`, `data`, and `resolve` of the componentless parent into\n * the `params`, `data`, and `resolve` of the children. This is done because there is no component\n * that can inject the activated route of the componentless parent.\n *\n * This is especially useful when child components are defined as follows:\n *\n * ```\n * [{\n *    path: 'parent/:id',\n *    children: [\n *      { path: '', component: MainChild },\n *      { path: '', component: AuxChild, outlet: 'aux' }\n *    ]\n * }]\n * ```\n *\n * With this configuration in place, navigating to '/parent/10' will create the main child and aux\n * components.\n *\n * ### Lazy Loading\n *\n * Lazy loading speeds up our application load time by splitting it into multiple bundles, and\n * loading them on demand. The router is designed to make lazy loading simple and easy. Instead of\n * providing the children property, you can provide the `loadChildren` property, as follows:\n *\n * ```\n * [{\n *   path: 'team/:id',\n *   component: Team,\n *   loadChildren: 'team'\n * }]\n * ```\n *\n * The router will use registered NgModuleFactoryLoader to fetch an NgModule associated with 'team'.\n * Then it will extract the set of routes defined in that NgModule, and will transparently add\n * those routes to the main configuration.\n *\n * @stable use Routes\n */\nexport type Routes = Route[];\n\n/**\n * @whatItDoes Represents the results of the URL matching.\n *\n * * `consumed` is an array of the consumed URL segments.\n * * `posParams` is a map of positional parameters.\n *\n * @experimental\n */\nexport type UrlMatchResult = {\n  consumed: UrlSegment[]; posParams?: {[name: string]: UrlSegment};\n};\n\n/**\n * @whatItDoes A function matching URLs\n *\n * @description\n *\n * A custom URL matcher can be provided when a combination of `path` and `pathMatch` isn't\n * expressive enough.\n *\n * For instance, the following matcher matches html files.\n *\n * ```\n * function htmlFiles(url: UrlSegment[]) {\n *  return url.length === 1 && url[0].path.endsWith('.html') ? ({consumed: url}) : null;\n * }\n *\n * const routes = [{ matcher: htmlFiles, component: HtmlCmp }];\n * ```\n *\n * @experimental\n */\nexport type UrlMatcher = (segments: UrlSegment[], group: UrlSegmentGroup, route: Route) =>\n    UrlMatchResult;\n\n/**\n * @whatItDoes Represents the static data associated with a particular route.\n * See {@link Routes} for more details.\n * @stable\n */\nexport type Data = {\n  [name: string]: any\n};\n\n/**\n * @whatItDoes Represents the resolved data associated with a particular route.\n * See {@link Routes} for more details.\n * @stable\n */\nexport type ResolveData = {\n  [name: string]: any\n};\n\n/**\n * @whatItDoes The type of `loadChildren`.\n * See {@link Routes} for more details.\n * @stable\n */\nexport type LoadChildrenCallback = () =>\n    Type<any>| NgModuleFactory<any>| Promise<Type<any>>| Observable<Type<any>>;\n\n/**\n * @whatItDoes The type of `loadChildren`.\n * See {@link Routes} for more details.\n * @stable\n */\nexport type LoadChildren = string | LoadChildrenCallback;\n\n/**\n * @whatItDoes The type of `queryParamsHandling`.\n * See {@link RouterLink} for more details.\n * @stable\n */\nexport type QueryParamsHandling = 'merge' | 'preserve' | '';\n\n/**\n * @whatItDoes The type of `runGuardsAndResolvers`.\n * See {@link Routes} for more details.\n * @experimental\n */\nexport type RunGuardsAndResolvers = 'paramsChange' | 'paramsOrQueryParamsChange' | 'always';\n\n/**\n * See {@link Routes} for more details.\n * @stable\n */\nexport interface Route {\n  path?: string;\n  pathMatch?: string;\n  matcher?: UrlMatcher;\n  component?: Type<any>;\n  redirectTo?: string;\n  outlet?: string;\n  canActivate?: any[];\n  canActivateChild?: any[];\n  canDeactivate?: any[];\n  canLoad?: any[];\n  data?: Data;\n  resolve?: ResolveData;\n  children?: Routes;\n  loadChildren?: LoadChildren;\n  runGuardsAndResolvers?: RunGuardsAndResolvers;\n  /**\n   * Filled for routes with `loadChildren` once the module has been loaded\n   * @internal\n   */\n  _loadedConfig?: LoadedRouterConfig;\n}\nexport class LoadedRouterConfig {\n/**\n * @param {?} routes\n * @param {?} module\n */\nconstructor(public routes: Route[],\npublic module: NgModuleRef<any>) {}\n}\n\nfunction LoadedRouterConfig_tsickle_Closure_declarations() {\n/** @type {?} */\nLoadedRouterConfig.prototype.routes;\n/** @type {?} */\nLoadedRouterConfig.prototype.module;\n}\n\n/**\n * @param {?} config\n * @param {?=} parentPath\n * @return {?}\n */\nexport function validateConfig(config: Routes, parentPath: string = ''): void {\n  // forEach doesn't iterate undefined values\n  for (let /** @type {?} */ i = 0; i < config.length; i++) {\n    const /** @type {?} */ route: Route = config[i];\n    const /** @type {?} */ fullPath: string = getFullPath(parentPath, route);\n    validateNode(route, fullPath);\n  }\n}\n/**\n * @param {?} route\n * @param {?} fullPath\n * @return {?}\n */\nfunction validateNode(route: Route, fullPath: string): void {\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.outlet && route.outlet !== PRIMARY_OUTLET)) {\n    throw new Error(\n        `Invalid configuration of route '${fullPath}': a componentless route cannot have a named outlet set`);\n  }\n  if (route.redirectTo && route.children) {\n    throw new Error(\n        `Invalid configuration of route '${fullPath}': redirectTo and children cannot be used together`);\n  }\n  if (route.redirectTo && route.loadChildren) {\n    throw new Error(\n        `Invalid configuration of route '${fullPath}': redirectTo and loadChildren cannot be used together`);\n  }\n  if (route.children && route.loadChildren) {\n    throw new Error(\n        `Invalid configuration of route '${fullPath}': children and loadChildren cannot be used together`);\n  }\n  if (route.redirectTo && route.component) {\n    throw new Error(\n        `Invalid configuration of route '${fullPath}': redirectTo and component cannot be used together`);\n  }\n  if (route.path && route.matcher) {\n    throw new Error(\n        `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(\n        `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(\n        `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    const /** @type {?} */ exp =\n        `The default value of 'pathMatch' is 'prefix', but often the intent is to use 'full'.`;\n    throw new Error(\n        `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(\n        `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}\n/**\n * @param {?} parentPath\n * @param {?} currentRoute\n * @return {?}\n */\nfunction getFullPath(parentPath: string, currentRoute: Route): string {\n  if (!currentRoute) {\n    return parentPath;\n  }\n  if (!parentPath && !currentRoute.path) {\n    return '';\n  } else if (parentPath && !currentRoute.path) {\n    return `${parentPath}/`;\n  } else if (!parentPath && currentRoute.path) {\n    return currentRoute.path;\n  } else {\n    return `${parentPath}/${currentRoute.path}`;\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\nimport {PRIMARY_OUTLET, ParamMap, convertToParamMap} from './shared';\nimport {forEach, shallowEqual} from './utils/collection';\n/**\n * @return {?}\n */\nexport function createEmptyUrlTree() {\n  return new UrlTree(new UrlSegmentGroup([], {}), {}, null);\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @param {?} exact\n * @return {?}\n */\nexport function containsTree(container: UrlTree, containee: UrlTree, exact: boolean): boolean {\n  if (exact) {\n    return equalQueryParams(container.queryParams, containee.queryParams) &&\n        equalSegmentGroups(container.root, containee.root);\n  }\n\n  return containsQueryParams(container.queryParams, containee.queryParams) &&\n      containsSegmentGroup(container.root, containee.root);\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @return {?}\n */\nfunction equalQueryParams(\n    container: {[k: string]: string}, containee: {[k: string]: string}): boolean {\n  return shallowEqual(container, containee);\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @return {?}\n */\nfunction equalSegmentGroups(container: UrlSegmentGroup, containee: UrlSegmentGroup): boolean {\n  if (!equalPath(container.segments, containee.segments)) return false;\n  if (container.numberOfChildren !== containee.numberOfChildren) return false;\n  for (const /** @type {?} */ c in containee.children) {\n    if (!container.children[c]) return false;\n    if (!equalSegmentGroups(container.children[c], containee.children[c])) return false;\n  }\n  return true;\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @return {?}\n */\nfunction containsQueryParams(\n    container: {[k: string]: string}, containee: {[k: string]: string}): boolean {\n  return Object.keys(containee).length <= Object.keys(container).length &&\n      Object.keys(containee).every(key => containee[key] === container[key]);\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @return {?}\n */\nfunction containsSegmentGroup(container: UrlSegmentGroup, containee: UrlSegmentGroup): boolean {\n  return containsSegmentGroupHelper(container, containee, containee.segments);\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @param {?} containeePaths\n * @return {?}\n */\nfunction containsSegmentGroupHelper(\n    container: UrlSegmentGroup, containee: UrlSegmentGroup, containeePaths: UrlSegment[]): boolean {\n  if (container.segments.length > containeePaths.length) {\n    const /** @type {?} */ current = container.segments.slice(0, containeePaths.length);\n    if (!equalPath(current, containeePaths)) return false;\n    if (containee.hasChildren()) return false;\n    return true;\n\n  } else if (container.segments.length === containeePaths.length) {\n    if (!equalPath(container.segments, containeePaths)) return false;\n    for (const /** @type {?} */ c in containee.children) {\n      if (!container.children[c]) return false;\n      if (!containsSegmentGroup(container.children[c], containee.children[c])) return false;\n    }\n    return true;\n\n  } else {\n    const /** @type {?} */ current = containeePaths.slice(0, container.segments.length);\n    const /** @type {?} */ next = containeePaths.slice(container.segments.length);\n    if (!equalPath(container.segments, current)) return false;\n    if (!container.children[PRIMARY_OUTLET]) return false;\n    return containsSegmentGroupHelper(container.children[PRIMARY_OUTLET], containee, next);\n  }\n}\n/**\n * \\@whatItDoes Represents the parsed URL.\n * \n * \\@howToUse \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 * \\@description \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 * \\@stable\n */\nexport class UrlTree {\n/**\n * \\@internal\n */\n_queryParamMap: ParamMap;\n/**\n * \\@internal\n * @param {?} root\n * @param {?} queryParams\n * @param {?} fragment\n */\nconstructor(\npublic root: UrlSegmentGroup,\npublic queryParams: {[key: string]: string},\npublic fragment: string|null) {}\n/**\n * @return {?}\n */\nget queryParamMap(): ParamMap {\n    if (!this._queryParamMap) {\n      this._queryParamMap = convertToParamMap(this.queryParams);\n    }\n    return this._queryParamMap;\n  }\n/**\n * \\@docsNotRequired\n * @return {?}\n */\ntoString(): string { return DEFAULT_SERIALIZER.serialize(this); }\n}\n\nfunction UrlTree_tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\nUrlTree.prototype._queryParamMap;\n/**\n * The root segment group of the URL tree\n * @type {?}\n */\nUrlTree.prototype.root;\n/**\n * The query params of the URL\n * @type {?}\n */\nUrlTree.prototype.queryParams;\n/**\n * The fragment of the URL\n * @type {?}\n */\nUrlTree.prototype.fragment;\n}\n\n/**\n * \\@whatItDoes Represents the parsed URL segment group.\n * \n * See {\\@link UrlTree} for more information.\n * \n * \\@stable\n */\nexport class UrlSegmentGroup {\n/**\n * \\@internal\n */\n_sourceSegment: UrlSegmentGroup;\n/**\n * \\@internal\n */\n_segmentIndexShift: number;\n/**\n * The parent node in the url tree\n */\nparent: UrlSegmentGroup|null = null;\n/**\n * @param {?} segments\n * @param {?} children\n */\nconstructor(\npublic segments: UrlSegment[],\npublic children: {[key: string]: UrlSegmentGroup}) {\n    forEach(children, (v: any, k: any) => v.parent = this);\n  }\n/**\n * Whether the segment has child segments\n * @return {?}\n */\nhasChildren(): boolean { return this.numberOfChildren > 0; }\n/**\n * Number of child segments\n * @return {?}\n */\nget numberOfChildren(): number { return Object.keys(this.children).length; }\n/**\n * \\@docsNotRequired\n * @return {?}\n */\ntoString(): string { return serializePaths(this); }\n}\n\nfunction UrlSegmentGroup_tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\nUrlSegmentGroup.prototype._sourceSegment;\n/**\n * \\@internal\n * @type {?}\n */\nUrlSegmentGroup.prototype._segmentIndexShift;\n/**\n * The parent node in the url tree\n * @type {?}\n */\nUrlSegmentGroup.prototype.parent;\n/**\n * The URL segments of this group. See {\\@link UrlSegment} for more information\n * @type {?}\n */\nUrlSegmentGroup.prototype.segments;\n/**\n * The list of children of this group\n * @type {?}\n */\nUrlSegmentGroup.prototype.children;\n}\n\n/**\n * \\@whatItDoes Represents a single URL segment.\n * \n * \\@howToUse \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 * \\@description \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 * \\@stable\n */\nexport class UrlSegment {\n/**\n * \\@internal\n */\n_parameterMap: ParamMap;\n/**\n * @param {?} path\n * @param {?} parameters\n */\nconstructor(\npublic path: string,\npublic parameters: {[name: string]: string}) {}\n/**\n * @return {?}\n */\nget parameterMap() {\n    if (!this._parameterMap) {\n      this._parameterMap = convertToParamMap(this.parameters);\n    }\n    return this._parameterMap;\n  }\n/**\n * \\@docsNotRequired\n * @return {?}\n */\ntoString(): string { return serializePath(this); }\n}\n\nfunction UrlSegment_tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\nUrlSegment.prototype._parameterMap;\n/**\n * The path part of a URL segment\n * @type {?}\n */\nUrlSegment.prototype.path;\n/**\n * The matrix parameters associated with a segment\n * @type {?}\n */\nUrlSegment.prototype.parameters;\n}\n\n/**\n * @param {?} as\n * @param {?} bs\n * @return {?}\n */\nexport function equalSegments(as: UrlSegment[], bs: UrlSegment[]): boolean {\n  return equalPath(as, bs) && as.every((a, i) => shallowEqual(a.parameters, bs[i].parameters));\n}\n/**\n * @param {?} as\n * @param {?} bs\n * @return {?}\n */\nexport function equalPath(as: UrlSegment[], bs: UrlSegment[]): boolean {\n  if (as.length !== bs.length) return false;\n  return as.every((a, i) => a.path === bs[i].path);\n}\n/**\n * @template T\n * @param {?} segment\n * @param {?} fn\n * @return {?}\n */\nexport function mapChildrenIntoArray<T>(\n    segment: UrlSegmentGroup, fn: (v: UrlSegmentGroup, k: string) => T[]): T[] {\n  let /** @type {?} */ res: T[] = [];\n  forEach(segment.children, (child: UrlSegmentGroup, childOutlet: string) => {\n    if (childOutlet === PRIMARY_OUTLET) {\n      res = res.concat(fn(child, childOutlet));\n    }\n  });\n  forEach(segment.children, (child: UrlSegmentGroup, childOutlet: string) => {\n    if (childOutlet !== PRIMARY_OUTLET) {\n      res = res.concat(fn(child, childOutlet));\n    }\n  });\n  return res;\n}\n/**\n * \\@whatItDoes Serializes and deserializes a URL string into a URL tree.\n * \n * \\@description The url serialization strategy is customizable. You can\n * make all URLs case insensitive by providing a custom UrlSerializer.\n * \n * See {\\@link DefaultUrlSerializer} for an example of a URL serializer.\n * \n * \\@stable\n * @abstract\n */\nexport abstract class UrlSerializer {\n/**\n * Parse a url into a {\\@link UrlTree}\n * @abstract\n * @param {?} url\n * @return {?}\n */\nparse(url: string) {}\n/**\n * Converts a {\\@link UrlTree} into a url\n * @abstract\n * @param {?} tree\n * @return {?}\n */\nserialize(tree: UrlTree) {}\n}\n/**\n * \\@whatItDoes A default implementation of the {\\@link UrlSerializer}.\n * \n * \\@description \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 * \\@stable\n */\nexport class DefaultUrlSerializer implements UrlSerializer {\n/**\n * Parses a url into a {\\@link UrlTree}\n * @param {?} url\n * @return {?}\n */\nparse(url: string): UrlTree {\n    const /** @type {?} */ p = new UrlParser(url);\n    return new UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment());\n  }\n/**\n * Converts a {\\@link UrlTree} into a url\n * @param {?} tree\n * @return {?}\n */\nserialize(tree: UrlTree): string {\n    const /** @type {?} */ segment = `/${serializeSegment(tree.root, true)}`;\n    const /** @type {?} */ query = serializeQueryParams(tree.queryParams);\n    const /** @type {?} */ fragment = typeof tree.fragment === `string` ? `#${encodeURI( /** @type {?} */((tree.fragment)))}` : '';\n\n    return `${segment}${query}${fragment}`;\n  }\n}\n\nconst /** @type {?} */ DEFAULT_SERIALIZER = new DefaultUrlSerializer();\n/**\n * @param {?} segment\n * @return {?}\n */\nexport function serializePaths(segment: UrlSegmentGroup): string {\n  return segment.segments.map(p => serializePath(p)).join('/');\n}\n/**\n * @param {?} segment\n * @param {?} root\n * @return {?}\n */\nfunction serializeSegment(segment: UrlSegmentGroup, root: boolean): string {\n  if (!segment.hasChildren()) {\n    return serializePaths(segment);\n  }\n\n  if (root) {\n    const /** @type {?} */ primary = segment.children[PRIMARY_OUTLET] ?\n        serializeSegment(segment.children[PRIMARY_OUTLET], false) :\n        '';\n    const /** @type {?} */ children: string[] = [];\n\n    forEach(segment.children, (v: UrlSegmentGroup, k: string) => {\n      if (k !== PRIMARY_OUTLET) {\n        children.push(`${k}:${serializeSegment(v, false)}`);\n      }\n    });\n\n    return children.length > 0 ? `${primary}(${children.join('//')})` : primary;\n\n  } else {\n    const /** @type {?} */ children = mapChildrenIntoArray(segment, (v: UrlSegmentGroup, k: string) => {\n      if (k === PRIMARY_OUTLET) {\n        return [serializeSegment(segment.children[PRIMARY_OUTLET], false)];\n      }\n\n      return [`${k}:${serializeSegment(v, false)}`];\n\n    });\n\n    return `${serializePaths(segment)}/(${children.join('//')})`;\n  }\n}\n/**\n * This method is intended for encoding *key* or *value* parts of query component. We need a custom\n * method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be\n * encoded per http://tools.ietf.org/html/rfc3986:\n *    query         = *( pchar / \"/\" / \"?\" )\n *    pchar         = unreserved / pct-encoded / sub-delims / \":\" / \"\\@\"\n *    unreserved    = ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\n *    pct-encoded   = \"%\" HEXDIG HEXDIG\n *    sub-delims    = \"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\"\n *                     / \"*\" / \"+\" / \",\" / \";\" / \"=\"\n * @param {?} s\n * @return {?}\n */\nexport function encode(s: string): string {\n  return encodeURIComponent(s)\n      .replace(/%40/g, '@')\n      .replace(/%3A/gi, ':')\n      .replace(/%24/g, '$')\n      .replace(/%2C/gi, ',')\n      .replace(/%3B/gi, ';');\n}\n/**\n * @param {?} s\n * @return {?}\n */\nexport function decode(s: string): string {\n  return decodeURIComponent(s);\n}\n/**\n * @param {?} path\n * @return {?}\n */\nexport function serializePath(path: UrlSegment): string {\n  return `${encode(path.path)}${serializeParams(path.parameters)}`;\n}\n/**\n * @param {?} params\n * @return {?}\n */\nfunction serializeParams(params: {[key: string]: string}): string {\n  return Object.keys(params).map(key => `;${encode(key)}=${encode(params[key])}`).join('');\n}\n/**\n * @param {?} params\n * @return {?}\n */\nfunction serializeQueryParams(params: {[key: string]: any}): string {\n  const /** @type {?} */ strParams: string[] = Object.keys(params).map((name) => {\n    const /** @type {?} */ value = params[name];\n    return Array.isArray(value) ? value.map(v => `${encode(name)}=${encode(v)}`).join('&') :\n                                  `${encode(name)}=${encode(value)}`;\n  });\n\n  return strParams.length ? `?${strParams.join(\"&\")}` : '';\n}\n\nconst /** @type {?} */ SEGMENT_RE = /^[^\\/()?;=&#]+/;\n/**\n * @param {?} str\n * @return {?}\n */\nfunction matchSegments(str: string): string {\n  const /** @type {?} */ match = str.match(SEGMENT_RE);\n  return match ? match[0] : '';\n}\n\nconst /** @type {?} */ QUERY_PARAM_RE = /^[^=?&#]+/;\n/**\n * @param {?} str\n * @return {?}\n */\nfunction matchQueryParams(str: string): string {\n  const /** @type {?} */ match = str.match(QUERY_PARAM_RE);\n  return match ? match[0] : '';\n}\n\nconst /** @type {?} */ QUERY_PARAM_VALUE_RE = /^[^?&#]+/;\n/**\n * @param {?} str\n * @return {?}\n */\nfunction matchUrlQueryParamValue(str: string): string {\n  const /** @type {?} */ match = str.match(QUERY_PARAM_VALUE_RE);\n  return match ? match[0] : '';\n}\nclass UrlParser {\nprivate remaining: string;\n/**\n * @param {?} url\n */\nconstructor(private url: string) { this.remaining = url; }\n/**\n * @return {?}\n */\nparseRootSegment(): UrlSegmentGroup {\n    this.consumeOptional('/');\n\n    if (this.remaining === '' || this.peekStartsWith('?') || this.peekStartsWith('#')) {\n      return new UrlSegmentGroup([], {});\n    }\n\n    // The root segment group never has segments\n    return new UrlSegmentGroup([], this.parseChildren());\n  }\n/**\n * @return {?}\n */\nparseQueryParams(): {[key: string]: any} {\n    const /** @type {?} */ params: {[key: string]: any} = {};\n    if (this.consumeOptional('?')) {\n      do {\n        this.parseQueryParam(params);\n      } while (this.consumeOptional('&'));\n    }\n    return params;\n  }\n/**\n * @return {?}\n */\nparseFragment(): string|null {\n    return this.consumeOptional('#') ? decodeURI(this.remaining) : null;\n  }\n/**\n * @return {?}\n */\nprivate parseChildren(): {[outlet: string]: UrlSegmentGroup} {\n    if (this.remaining === '') {\n      return {};\n    }\n\n    this.consumeOptional('/');\n\n    const /** @type {?} */ segments: UrlSegment[] = [];\n    if (!this.peekStartsWith('(')) {\n      segments.push(this.parseSegment());\n    }\n\n    while (this.peekStartsWith('/') && !this.peekStartsWith('//') && !this.peekStartsWith('/(')) {\n      this.capture('/');\n      segments.push(this.parseSegment());\n    }\n\n    let /** @type {?} */ children: {[outlet: string]: UrlSegmentGroup} = {};\n    if (this.peekStartsWith('/(')) {\n      this.capture('/');\n      children = this.parseParens(true);\n    }\n\n    let /** @type {?} */ res: {[outlet: string]: UrlSegmentGroup} = {};\n    if (this.peekStartsWith('(')) {\n      res = this.parseParens(false);\n    }\n\n    if (segments.length > 0 || Object.keys(children).length > 0) {\n      res[PRIMARY_OUTLET] = new UrlSegmentGroup(segments, children);\n    }\n\n    return res;\n  }\n/**\n * @return {?}\n */\nprivate parseSegment(): UrlSegment {\n    const /** @type {?} */ path = matchSegments(this.remaining);\n    if (path === '' && this.peekStartsWith(';')) {\n      throw new Error(`Empty path url segment cannot have parameters: '${this.remaining}'.`);\n    }\n\n    this.capture(path);\n    return new UrlSegment(decode(path), this.parseMatrixParams());\n  }\n/**\n * @return {?}\n */\nprivate parseMatrixParams(): {[key: string]: any} {\n    const /** @type {?} */ params: {[key: string]: any} = {};\n    while (this.consumeOptional(';')) {\n      this.parseParam(params);\n    }\n    return params;\n  }\n/**\n * @param {?} params\n * @return {?}\n */\nprivate parseParam(params: {[key: string]: any}): void {\n    const /** @type {?} */ key = matchSegments(this.remaining);\n    if (!key) {\n      return;\n    }\n    this.capture(key);\n    let /** @type {?} */ value: any = '';\n    if (this.consumeOptional('=')) {\n      const /** @type {?} */ valueMatch = matchSegments(this.remaining);\n      if (valueMatch) {\n        value = valueMatch;\n        this.capture(value);\n      }\n    }\n\n    params[decode(key)] = decode(value);\n  }\n/**\n * @param {?} params\n * @return {?}\n */\nprivate parseQueryParam(params: {[key: string]: any}): void {\n    const /** @type {?} */ key = matchQueryParams(this.remaining);\n    if (!key) {\n      return;\n    }\n    this.capture(key);\n    let /** @type {?} */ value: any = '';\n    if (this.consumeOptional('=')) {\n      const /** @type {?} */ valueMatch = matchUrlQueryParamValue(this.remaining);\n      if (valueMatch) {\n        value = valueMatch;\n        this.capture(value);\n      }\n    }\n\n    const /** @type {?} */ decodedKey = decode(key);\n    const /** @type {?} */ decodedVal = decode(value);\n\n    if (params.hasOwnProperty(decodedKey)) {\n      // Append to existing values\n      let /** @type {?} */ currentVal = params[decodedKey];\n      if (!Array.isArray(currentVal)) {\n        currentVal = [currentVal];\n        params[decodedKey] = currentVal;\n      }\n      currentVal.push(decodedVal);\n    } else {\n      // Create a new value\n      params[decodedKey] = decodedVal;\n    }\n  }\n/**\n * @param {?} allowPrimary\n * @return {?}\n */\nprivate parseParens(allowPrimary: boolean): {[outlet: string]: UrlSegmentGroup} {\n    const /** @type {?} */ segments: {[key: string]: UrlSegmentGroup} = {};\n    this.capture('(');\n\n    while (!this.consumeOptional(')') && this.remaining.length > 0) {\n      const /** @type {?} */ path = matchSegments(this.remaining);\n\n      const /** @type {?} */ next = this.remaining[path.length];\n\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\n      let /** @type {?} */ outletName: string = /** @type {?} */(( undefined));\n      if (path.indexOf(':') > -1) {\n        outletName = path.substr(0, path.indexOf(':'));\n        this.capture(outletName);\n        this.capture(':');\n      } else if (allowPrimary) {\n        outletName = PRIMARY_OUTLET;\n      }\n\n      const /** @type {?} */ children = this.parseChildren();\n      segments[outletName] = Object.keys(children).length === 1 ? children[PRIMARY_OUTLET] :\n                                                                  new UrlSegmentGroup([], children);\n      this.consumeOptional('//');\n    }\n\n    return segments;\n  }\n/**\n * @param {?} str\n * @return {?}\n */\nprivate peekStartsWith(str: string): boolean { return this.remaining.startsWith(str); }\n/**\n * @param {?} str\n * @return {?}\n */\nprivate consumeOptional(str: string): boolean {\n    if (this.peekStartsWith(str)) {\n      this.remaining = this.remaining.substring(str.length);\n      return true;\n    }\n    return false;\n  }\n/**\n * @param {?} str\n * @return {?}\n */\nprivate capture(str: string): void {\n    if (!this.consumeOptional(str)) {\n      throw new Error(`Expected \"${str}\".`);\n    }\n  }\n}\n\nfunction UrlParser_tsickle_Closure_declarations() {\n/** @type {?} */\nUrlParser.prototype.remaining;\n/** @type {?} */\nUrlParser.prototype.url;\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\nimport {Injector, NgModuleRef} from '@angular/core';\nimport {Observable} from 'rxjs/Observable';\nimport {Observer} from 'rxjs/Observer';\nimport {from} from 'rxjs/observable/from';\nimport {of } from 'rxjs/observable/of';\nimport {_catch} from 'rxjs/operator/catch';\nimport {concatAll} from 'rxjs/operator/concatAll';\nimport {first} from 'rxjs/operator/first';\nimport {map} from 'rxjs/operator/map';\nimport {mergeMap} from 'rxjs/operator/mergeMap';\nimport {EmptyError} from 'rxjs/util/EmptyError';\n\nimport {LoadedRouterConfig, Route, Routes} from './config';\nimport {RouterConfigLoader} from './router_config_loader';\nimport {PRIMARY_OUTLET, Params, defaultUrlMatcher, navigationCancelingError} from './shared';\nimport {UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree} from './url_tree';\nimport {andObservables, forEach, waitForMap, wrapIntoObservable} from './utils/collection';\nclass NoMatch {\npublic segmentGroup: UrlSegmentGroup|null;\n/**\n * @param {?=} segmentGroup\n */\nconstructor(segmentGroup?: UrlSegmentGroup) { this.segmentGroup = segmentGroup || null; }\n}\n\nfunction NoMatch_tsickle_Closure_declarations() {\n/** @type {?} */\nNoMatch.prototype.segmentGroup;\n}\n\nclass AbsoluteRedirect {\n/**\n * @param {?} urlTree\n */\nconstructor(public urlTree: UrlTree) {}\n}\n\nfunction AbsoluteRedirect_tsickle_Closure_declarations() {\n/** @type {?} */\nAbsoluteRedirect.prototype.urlTree;\n}\n\n/**\n * @param {?} segmentGroup\n * @return {?}\n */\nfunction noMatch(segmentGroup: UrlSegmentGroup): Observable<UrlSegmentGroup> {\n  return new Observable<UrlSegmentGroup>(\n      (obs: Observer<UrlSegmentGroup>) => obs.error(new NoMatch(segmentGroup)));\n}\n/**\n * @param {?} newTree\n * @return {?}\n */\nfunction absoluteRedirect(newTree: UrlTree): Observable<any> {\n  return new Observable<UrlSegmentGroup>(\n      (obs: Observer<UrlSegmentGroup>) => obs.error(new AbsoluteRedirect(newTree)));\n}\n/**\n * @param {?} redirectTo\n * @return {?}\n */\nfunction namedOutletsRedirect(redirectTo: string): Observable<any> {\n  return new Observable<UrlSegmentGroup>(\n      (obs: Observer<UrlSegmentGroup>) => obs.error(new Error(\n          `Only absolute redirects can have named outlets. redirectTo: '${redirectTo}'`)));\n}\n/**\n * @param {?} route\n * @return {?}\n */\nfunction canLoadFails(route: Route): Observable<LoadedRouterConfig> {\n  return new Observable<LoadedRouterConfig>(\n      (obs: Observer<LoadedRouterConfig>) => obs.error(navigationCancelingError(\n          `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 * @param {?} moduleInjector\n * @param {?} configLoader\n * @param {?} urlSerializer\n * @param {?} urlTree\n * @param {?} config\n * @return {?}\n */\nexport function applyRedirects(\n    moduleInjector: Injector, configLoader: RouterConfigLoader, urlSerializer: UrlSerializer,\n    urlTree: UrlTree, config: Routes): Observable<UrlTree> {\n  return new ApplyRedirects(moduleInjector, configLoader, urlSerializer, urlTree, config).apply();\n}\nclass ApplyRedirects {\nprivate allowRedirects: boolean = true;\nprivate ngModule: NgModuleRef<any>;\n/**\n * @param {?} moduleInjector\n * @param {?} configLoader\n * @param {?} urlSerializer\n * @param {?} urlTree\n * @param {?} config\n */\nconstructor(\n      moduleInjector: Injector,\nprivate configLoader: RouterConfigLoader,\nprivate urlSerializer: UrlSerializer,\nprivate urlTree: UrlTree,\nprivate config: Routes) {\n    this.ngModule = moduleInjector.get(NgModuleRef);\n  }\n/**\n * @return {?}\n */\napply(): Observable<UrlTree> {\n    const /** @type {?} */ expanded$ =\n        this.expandSegmentGroup(this.ngModule, this.config, this.urlTree.root, PRIMARY_OUTLET);\n    const /** @type {?} */ urlTrees$ = map.call(\n        expanded$, (rootSegmentGroup: UrlSegmentGroup) => this.createUrlTree(\n                       rootSegmentGroup, this.urlTree.queryParams, /** @type {?} */(( this.urlTree.fragment))));\n    return _catch.call(urlTrees$, (e: any) => {\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\n      if (e instanceof NoMatch) {\n        throw this.noMatchError(e);\n      }\n\n      throw e;\n    });\n  }\n/**\n * @param {?} tree\n * @return {?}\n */\nprivate match(tree: UrlTree): Observable<UrlTree> {\n    const /** @type {?} */ expanded$ =\n        this.expandSegmentGroup(this.ngModule, this.config, tree.root, PRIMARY_OUTLET);\n    const /** @type {?} */ mapped$ = map.call(\n        expanded$, (rootSegmentGroup: UrlSegmentGroup) =>\n                       this.createUrlTree(rootSegmentGroup, tree.queryParams, /** @type {?} */(( tree.fragment))));\n    return _catch.call(mapped$, (e: any): Observable<UrlTree> => {\n      if (e instanceof NoMatch) {\n        throw this.noMatchError(e);\n      }\n\n      throw e;\n    });\n  }\n/**\n * @param {?} e\n * @return {?}\n */\nprivate noMatchError(e: NoMatch): any {\n    return new Error(`Cannot match any routes. URL Segment: '${e.segmentGroup}'`);\n  }\n/**\n * @param {?} rootCandidate\n * @param {?} queryParams\n * @param {?} fragment\n * @return {?}\n */\nprivate createUrlTree(rootCandidate: UrlSegmentGroup, queryParams: Params, fragment: string):\n      UrlTree {\n    const /** @type {?} */ root = rootCandidate.segments.length > 0 ?\n        new UrlSegmentGroup([], {[PRIMARY_OUTLET]: rootCandidate}) :\n        rootCandidate;\n    return new UrlTree(root, queryParams, fragment);\n  }\n/**\n * @param {?} ngModule\n * @param {?} routes\n * @param {?} segmentGroup\n * @param {?} outlet\n * @return {?}\n */\nprivate expandSegmentGroup(\n      ngModule: NgModuleRef<any>, routes: Route[], segmentGroup: UrlSegmentGroup,\n      outlet: string): Observable<UrlSegmentGroup> {\n    if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {\n      return map.call(\n          this.expandChildren(ngModule, routes, segmentGroup),\n          (children: any) => new UrlSegmentGroup([], children));\n    }\n\n    return this.expandSegment(ngModule, segmentGroup, routes, segmentGroup.segments, outlet, true);\n  }\n/**\n * @param {?} ngModule\n * @param {?} routes\n * @param {?} segmentGroup\n * @return {?}\n */\nprivate expandChildren(\n      ngModule: NgModuleRef<any>, routes: Route[],\n      segmentGroup: UrlSegmentGroup): Observable<{[name: string]: UrlSegmentGroup}> {\n    return waitForMap(\n        segmentGroup.children,\n        (childOutlet, child) => this.expandSegmentGroup(ngModule, routes, child, childOutlet));\n  }\n/**\n * @param {?} ngModule\n * @param {?} segmentGroup\n * @param {?} routes\n * @param {?} segments\n * @param {?} outlet\n * @param {?} allowRedirects\n * @return {?}\n */\nprivate expandSegment(\n      ngModule: NgModuleRef<any>, segmentGroup: UrlSegmentGroup, routes: Route[],\n      segments: UrlSegment[], outlet: string,\n      allowRedirects: boolean): Observable<UrlSegmentGroup> {\n    const /** @type {?} */ routes$ = of (...routes);\n    const /** @type {?} */ processedRoutes$ = map.call(routes$, (r: any) => {\n      const /** @type {?} */ expanded$ = this.expandSegmentAgainstRoute(\n          ngModule, segmentGroup, routes, r, segments, outlet, allowRedirects);\n      return _catch.call(expanded$, (e: any) => {\n        if (e instanceof NoMatch) {\n          return of (null);\n        }\n\n        throw e;\n      });\n    });\n    const /** @type {?} */ concattedProcessedRoutes$ = concatAll.call(processedRoutes$);\n    const /** @type {?} */ first$ = first.call(concattedProcessedRoutes$, (s: any) => !!s);\n    return _catch.call(first$, (e: any, _: any): Observable<UrlSegmentGroup> => {\n      if (e instanceof EmptyError) {\n        if (this.noLeftoversInUrl(segmentGroup, segments, outlet)) {\n          return of (new UrlSegmentGroup([], {}));\n        }\n\n        throw new NoMatch(segmentGroup);\n      }\n\n      throw e;\n    });\n  }\n/**\n * @param {?} segmentGroup\n * @param {?} segments\n * @param {?} outlet\n * @return {?}\n */\nprivate noLeftoversInUrl(segmentGroup: UrlSegmentGroup, segments: UrlSegment[], outlet: string):\n      boolean {\n    return segments.length === 0 && !segmentGroup.children[outlet];\n  }\n/**\n * @param {?} ngModule\n * @param {?} segmentGroup\n * @param {?} routes\n * @param {?} route\n * @param {?} paths\n * @param {?} outlet\n * @param {?} allowRedirects\n * @return {?}\n */\nprivate expandSegmentAgainstRoute(\n      ngModule: NgModuleRef<any>, segmentGroup: UrlSegmentGroup, routes: Route[], route: Route,\n      paths: UrlSegment[], outlet: string, allowRedirects: boolean): Observable<UrlSegmentGroup> {\n    if (getOutlet(route) !== outlet) {\n      return noMatch(segmentGroup);\n    }\n\n    if (route.redirectTo === undefined) {\n      return this.matchSegmentAgainstRoute(ngModule, segmentGroup, route, paths);\n    }\n\n    if (allowRedirects && this.allowRedirects) {\n      return this.expandSegmentAgainstRouteUsingRedirect(\n          ngModule, segmentGroup, routes, route, paths, outlet);\n    }\n\n    return noMatch(segmentGroup);\n  }\n/**\n * @param {?} ngModule\n * @param {?} segmentGroup\n * @param {?} routes\n * @param {?} route\n * @param {?} segments\n * @param {?} outlet\n * @return {?}\n */\nprivate expandSegmentAgainstRouteUsingRedirect(\n      ngModule: NgModuleRef<any>, segmentGroup: UrlSegmentGroup, routes: Route[], route: Route,\n      segments: UrlSegment[], outlet: string): Observable<UrlSegmentGroup> {\n    if (route.path === '**') {\n      return this.expandWildCardWithParamsAgainstRouteUsingRedirect(\n          ngModule, routes, route, outlet);\n    }\n\n    return this.expandRegularSegmentAgainstRouteUsingRedirect(\n        ngModule, segmentGroup, routes, route, segments, outlet);\n  }\n/**\n * @param {?} ngModule\n * @param {?} routes\n * @param {?} route\n * @param {?} outlet\n * @return {?}\n */\nprivate expandWildCardWithParamsAgainstRouteUsingRedirect(\n      ngModule: NgModuleRef<any>, routes: Route[], route: Route,\n      outlet: string): Observable<UrlSegmentGroup> {\n    const /** @type {?} */ newTree = this.applyRedirectCommands([], /** @type {?} */(( route.redirectTo)), {});\n    if ( /** @type {?} */((route.redirectTo)).startsWith('/')) {\n      return absoluteRedirect(newTree);\n    }\n\n    return mergeMap.call(this.lineralizeSegments(route, newTree), (newSegments: UrlSegment[]) => {\n      const /** @type {?} */ group = new UrlSegmentGroup(newSegments, {});\n      return this.expandSegment(ngModule, group, routes, newSegments, outlet, false);\n    });\n  }\n/**\n * @param {?} ngModule\n * @param {?} segmentGroup\n * @param {?} routes\n * @param {?} route\n * @param {?} segments\n * @param {?} outlet\n * @return {?}\n */\nprivate expandRegularSegmentAgainstRouteUsingRedirect(\n      ngModule: NgModuleRef<any>, segmentGroup: UrlSegmentGroup, routes: Route[], route: Route,\n      segments: UrlSegment[], outlet: string): Observable<UrlSegmentGroup> {\n    const {matched, consumedSegments, lastChild, positionalParamSegments} =\n        match(segmentGroup, route, segments);\n    if (!matched) return noMatch(segmentGroup);\n\n    const /** @type {?} */ newTree = this.applyRedirectCommands(\n        consumedSegments, /** @type {?} */(( route.redirectTo)), /** @type {?} */(( <any>positionalParamSegments)));\n    if ( /** @type {?} */((route.redirectTo)).startsWith('/')) {\n      return absoluteRedirect(newTree);\n    }\n\n    return mergeMap.call(this.lineralizeSegments(route, newTree), (newSegments: UrlSegment[]) => {\n      return this.expandSegment(\n          ngModule, segmentGroup, routes, newSegments.concat(segments.slice(lastChild)), outlet,\n          false);\n    });\n  }\n/**\n * @param {?} ngModule\n * @param {?} rawSegmentGroup\n * @param {?} route\n * @param {?} segments\n * @return {?}\n */\nprivate matchSegmentAgainstRoute(\n      ngModule: NgModuleRef<any>, rawSegmentGroup: UrlSegmentGroup, route: Route,\n      segments: UrlSegment[]): Observable<UrlSegmentGroup> {\n    if (route.path === '**') {\n      if (route.loadChildren) {\n        return map.call(\n            this.configLoader.load(ngModule.injector, route), (cfg: LoadedRouterConfig) => {\n              route._loadedConfig = cfg;\n              return new UrlSegmentGroup(segments, {});\n            });\n      }\n\n      return of (new UrlSegmentGroup(segments, {}));\n    }\n\n    const {matched, consumedSegments, lastChild} = match(rawSegmentGroup, route, segments);\n    if (!matched) return noMatch(rawSegmentGroup);\n\n    const /** @type {?} */ rawSlicedSegments = segments.slice(lastChild);\n    const /** @type {?} */ childConfig$ = this.getChildConfig(ngModule, route);\n\n    return mergeMap.call(childConfig$, (routerConfig: LoadedRouterConfig) => {\n      const /** @type {?} */ childModule = routerConfig.module;\n      const /** @type {?} */ childConfig = routerConfig.routes;\n\n      const {segmentGroup, slicedSegments} =\n          split(rawSegmentGroup, consumedSegments, rawSlicedSegments, childConfig);\n\n      if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {\n        const /** @type {?} */ expanded$ = this.expandChildren(childModule, childConfig, segmentGroup);\n        return map.call(\n            expanded$, (children: any) => new UrlSegmentGroup(consumedSegments, children));\n      }\n\n      if (childConfig.length === 0 && slicedSegments.length === 0) {\n        return of (new UrlSegmentGroup(consumedSegments, {}));\n      }\n\n      const /** @type {?} */ expanded$ = this.expandSegment(\n          childModule, segmentGroup, childConfig, slicedSegments, PRIMARY_OUTLET, true);\n      return map.call(\n          expanded$, (cs: UrlSegmentGroup) =>\n                         new UrlSegmentGroup(consumedSegments.concat(cs.segments), cs.children));\n    });\n  }\n/**\n * @param {?} ngModule\n * @param {?} route\n * @return {?}\n */\nprivate getChildConfig(ngModule: NgModuleRef<any>, route: Route): Observable<LoadedRouterConfig> {\n    if (route.children) {\n      // The children belong to the same module\n      return of (new LoadedRouterConfig(route.children, ngModule));\n    }\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\n      return mergeMap.call(runCanLoadGuard(ngModule.injector, route), (shouldLoad: boolean) => {\n\n        if (shouldLoad) {\n          return map.call(\n              this.configLoader.load(ngModule.injector, route), (cfg: LoadedRouterConfig) => {\n                route._loadedConfig = cfg;\n                return cfg;\n              });\n        }\n\n        return canLoadFails(route);\n      });\n    }\n\n    return of (new LoadedRouterConfig([], ngModule));\n  }\n/**\n * @param {?} route\n * @param {?} urlTree\n * @return {?}\n */\nprivate lineralizeSegments(route: Route, urlTree: UrlTree): Observable<UrlSegment[]> {\n    let /** @type {?} */ res: UrlSegment[] = [];\n    let /** @type {?} */ c = urlTree.root;\n    while (true) {\n      res = res.concat(c.segments);\n      if (c.numberOfChildren === 0) {\n        return of (res);\n      }\n\n      if (c.numberOfChildren > 1 || !c.children[PRIMARY_OUTLET]) {\n        return namedOutletsRedirect( /** @type {?} */((route.redirectTo)));\n      }\n\n      c = c.children[PRIMARY_OUTLET];\n    }\n  }\n/**\n * @param {?} segments\n * @param {?} redirectTo\n * @param {?} posParams\n * @return {?}\n */\nprivate applyRedirectCommands(\n      segments: UrlSegment[], redirectTo: string, posParams: {[k: string]: UrlSegment}): UrlTree {\n    return this.applyRedirectCreatreUrlTree(\n        redirectTo, this.urlSerializer.parse(redirectTo), segments, posParams);\n  }\n/**\n * @param {?} redirectTo\n * @param {?} urlTree\n * @param {?} segments\n * @param {?} posParams\n * @return {?}\n */\nprivate applyRedirectCreatreUrlTree(\n      redirectTo: string, urlTree: UrlTree, segments: UrlSegment[],\n      posParams: {[k: string]: UrlSegment}): UrlTree {\n    const /** @type {?} */ newRoot = this.createSegmentGroup(redirectTo, urlTree.root, segments, posParams);\n    return new UrlTree(\n        newRoot, this.createQueryParams(urlTree.queryParams, this.urlTree.queryParams),\n        urlTree.fragment);\n  }\n/**\n * @param {?} redirectToParams\n * @param {?} actualParams\n * @return {?}\n */\nprivate createQueryParams(redirectToParams: Params, actualParams: Params): Params {\n    const /** @type {?} */ res: Params = {};\n    forEach(redirectToParams, (v: any, k: string) => {\n      const /** @type {?} */ copySourceValue = typeof v === 'string' && v.startsWith(':');\n      if (copySourceValue) {\n        const /** @type {?} */ sourceName = v.substring(1);\n        res[k] = actualParams[sourceName];\n      } else {\n        res[k] = v;\n      }\n    });\n    return res;\n  }\n/**\n * @param {?} redirectTo\n * @param {?} group\n * @param {?} segments\n * @param {?} posParams\n * @return {?}\n */\nprivate createSegmentGroup(\n      redirectTo: string, group: UrlSegmentGroup, segments: UrlSegment[],\n      posParams: {[k: string]: UrlSegment}): UrlSegmentGroup {\n    const /** @type {?} */ updatedSegments = this.createSegments(redirectTo, group.segments, segments, posParams);\n\n    let /** @type {?} */ children: {[n: string]: UrlSegmentGroup} = {};\n    forEach(group.children, (child: UrlSegmentGroup, name: string) => {\n      children[name] = this.createSegmentGroup(redirectTo, child, segments, posParams);\n    });\n\n    return new UrlSegmentGroup(updatedSegments, children);\n  }\n/**\n * @param {?} redirectTo\n * @param {?} redirectToSegments\n * @param {?} actualSegments\n * @param {?} posParams\n * @return {?}\n */\nprivate createSegments(\n      redirectTo: string, redirectToSegments: UrlSegment[], actualSegments: UrlSegment[],\n      posParams: {[k: string]: UrlSegment}): UrlSegment[] {\n    return redirectToSegments.map(\n        s => s.path.startsWith(':') ? this.findPosParam(redirectTo, s, posParams) :\n                                      this.findOrReturn(s, actualSegments));\n  }\n/**\n * @param {?} redirectTo\n * @param {?} redirectToUrlSegment\n * @param {?} posParams\n * @return {?}\n */\nprivate findPosParam(\n      redirectTo: string, redirectToUrlSegment: UrlSegment,\n      posParams: {[k: string]: UrlSegment}): UrlSegment {\n    const /** @type {?} */ pos = posParams[redirectToUrlSegment.path.substring(1)];\n    if (!pos)\n      throw new Error(\n          `Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);\n    return pos;\n  }\n/**\n * @param {?} redirectToUrlSegment\n * @param {?} actualSegments\n * @return {?}\n */\nprivate findOrReturn(redirectToUrlSegment: UrlSegment, actualSegments: UrlSegment[]): UrlSegment {\n    let /** @type {?} */ idx = 0;\n    for (const /** @type {?} */ s of actualSegments) {\n      if (s.path === redirectToUrlSegment.path) {\n        actualSegments.splice(idx);\n        return s;\n      }\n      idx++;\n    }\n    return redirectToUrlSegment;\n  }\n}\n\nfunction ApplyRedirects_tsickle_Closure_declarations() {\n/** @type {?} */\nApplyRedirects.prototype.allowRedirects;\n/** @type {?} */\nApplyRedirects.prototype.ngModule;\n/** @type {?} */\nApplyRedirects.prototype.configLoader;\n/** @type {?} */\nApplyRedirects.prototype.urlSerializer;\n/** @type {?} */\nApplyRedirects.prototype.urlTree;\n/** @type {?} */\nApplyRedirects.prototype.config;\n}\n\n/**\n * @param {?} moduleInjector\n * @param {?} route\n * @return {?}\n */\nfunction runCanLoadGuard(moduleInjector: Injector, route: Route): Observable<boolean> {\n  const /** @type {?} */ canLoad = route.canLoad;\n  if (!canLoad || canLoad.length === 0) return of (true);\n\n  const /** @type {?} */ obs = map.call(from(canLoad), (injectionToken: any) => {\n    const /** @type {?} */ guard = moduleInjector.get(injectionToken);\n    return wrapIntoObservable(guard.canLoad ? guard.canLoad(route) : guard(route));\n  });\n\n  return andObservables(obs);\n}\n/**\n * @param {?} segmentGroup\n * @param {?} route\n * @param {?} segments\n * @return {?}\n */\nfunction match(segmentGroup: UrlSegmentGroup, route: Route, segments: UrlSegment[]): {\n  matched: boolean,\n  consumedSegments: UrlSegment[],\n  lastChild: number,\n  positionalParamSegments: {[k: string]: UrlSegment}\n} {\n  if (route.path === '') {\n    if ((route.pathMatch === 'full') && (segmentGroup.hasChildren() || segments.length > 0)) {\n      return {matched: false, consumedSegments: [], lastChild: 0, positionalParamSegments: {}};\n    }\n\n    return {matched: true, consumedSegments: [], lastChild: 0, positionalParamSegments: {}};\n  }\n\n  const /** @type {?} */ matcher = route.matcher || defaultUrlMatcher;\n  const /** @type {?} */ res = matcher(segments, segmentGroup, route);\n\n  if (!res) {\n    return {\n      matched: false,\n      consumedSegments: /** @type {?} */(( <any[]>[])),\n      lastChild: 0,\n      positionalParamSegments: {},\n    };\n  }\n\n  return {\n    matched: true,\n    consumedSegments: /** @type {?} */(( res.consumed)),\n    lastChild: /** @type {?} */(( res.consumed.length)),\n    positionalParamSegments: /** @type {?} */(( res.posParams)),\n  };\n}\n/**\n * @param {?} segmentGroup\n * @param {?} consumedSegments\n * @param {?} slicedSegments\n * @param {?} config\n * @return {?}\n */\nfunction split(\n    segmentGroup: UrlSegmentGroup, consumedSegments: UrlSegment[], slicedSegments: UrlSegment[],\n    config: Route[]) {\n  if (slicedSegments.length > 0 &&\n      containsEmptyPathRedirectsWithNamedOutlets(segmentGroup, slicedSegments, config)) {\n    const /** @type {?} */ s = new UrlSegmentGroup(\n        consumedSegments, createChildrenForEmptySegments(\n                              config, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));\n    return {segmentGroup: mergeTrivialChildren(s), slicedSegments: []};\n  }\n\n  if (slicedSegments.length === 0 &&\n      containsEmptyPathRedirects(segmentGroup, slicedSegments, config)) {\n    const /** @type {?} */ s = new UrlSegmentGroup(\n        segmentGroup.segments, addEmptySegmentsToChildrenIfNeeded(\n                                   segmentGroup, slicedSegments, config, segmentGroup.children));\n    return {segmentGroup: mergeTrivialChildren(s), slicedSegments};\n  }\n\n  return {segmentGroup, slicedSegments};\n}\n/**\n * @param {?} s\n * @return {?}\n */\nfunction mergeTrivialChildren(s: UrlSegmentGroup): UrlSegmentGroup {\n  if (s.numberOfChildren === 1 && s.children[PRIMARY_OUTLET]) {\n    const /** @type {?} */ c = s.children[PRIMARY_OUTLET];\n    return new UrlSegmentGroup(s.segments.concat(c.segments), c.children);\n  }\n\n  return s;\n}\n/**\n * @param {?} segmentGroup\n * @param {?} slicedSegments\n * @param {?} routes\n * @param {?} children\n * @return {?}\n */\nfunction addEmptySegmentsToChildrenIfNeeded(\n    segmentGroup: UrlSegmentGroup, slicedSegments: UrlSegment[], routes: Route[],\n    children: {[name: string]: UrlSegmentGroup}): {[name: string]: UrlSegmentGroup} {\n  const /** @type {?} */ res: {[name: string]: UrlSegmentGroup} = {};\n  for (const /** @type {?} */ r of routes) {\n    if (isEmptyPathRedirect(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {\n      res[getOutlet(r)] = new UrlSegmentGroup([], {});\n    }\n  }\n  return {...children, ...res};\n}\n/**\n * @param {?} routes\n * @param {?} primarySegmentGroup\n * @return {?}\n */\nfunction createChildrenForEmptySegments(\n    routes: Route[], primarySegmentGroup: UrlSegmentGroup): {[name: string]: UrlSegmentGroup} {\n  const /** @type {?} */ res: {[name: string]: UrlSegmentGroup} = {};\n  res[PRIMARY_OUTLET] = primarySegmentGroup;\n  for (const /** @type {?} */ r of routes) {\n    if (r.path === '' && getOutlet(r) !== PRIMARY_OUTLET) {\n      res[getOutlet(r)] = new UrlSegmentGroup([], {});\n    }\n  }\n  return res;\n}\n/**\n * @param {?} segmentGroup\n * @param {?} segments\n * @param {?} routes\n * @return {?}\n */\nfunction containsEmptyPathRedirectsWithNamedOutlets(\n    segmentGroup: UrlSegmentGroup, segments: UrlSegment[], routes: Route[]): boolean {\n  return routes.some(\n      r => isEmptyPathRedirect(segmentGroup, segments, r) && getOutlet(r) !== PRIMARY_OUTLET);\n}\n/**\n * @param {?} segmentGroup\n * @param {?} segments\n * @param {?} routes\n * @return {?}\n */\nfunction containsEmptyPathRedirects(\n    segmentGroup: UrlSegmentGroup, segments: UrlSegment[], routes: Route[]): boolean {\n  return routes.some(r => isEmptyPathRedirect(segmentGroup, segments, r));\n}\n/**\n * @param {?} segmentGroup\n * @param {?} segments\n * @param {?} r\n * @return {?}\n */\nfunction isEmptyPathRedirect(\n    segmentGroup: UrlSegmentGroup, segments: UrlSegment[], r: Route): boolean {\n  if ((segmentGroup.hasChildren() || segments.length > 0) && r.pathMatch === 'full') {\n    return false;\n  }\n\n  return r.path === '' && r.redirectTo !== undefined;\n}\n/**\n * @param {?} route\n * @return {?}\n */\nfunction getOutlet(route: Route): string {\n  return route.outlet || PRIMARY_OUTLET;\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\nimport {Type} from '@angular/core';\nimport {BehaviorSubject} from 'rxjs/BehaviorSubject';\nimport {Observable} from 'rxjs/Observable';\nimport {map} from 'rxjs/operator/map';\n\nimport {Data, ResolveData, Route} from './config';\nimport {PRIMARY_OUTLET, ParamMap, Params, convertToParamMap} from './shared';\nimport {UrlSegment, UrlSegmentGroup, UrlTree, equalSegments} from './url_tree';\nimport {shallowEqual, shallowEqualArrays} from './utils/collection';\nimport {Tree, TreeNode} from './utils/tree';\n/**\n * \\@whatItDoes Represents the state of the router.\n * \n * \\@howToUse \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<string> = child.params.map(p => p.id);\n *     //...\n *   }\n * }\n * ```\n * \n * \\@description \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 * See {\\@link ActivatedRoute} for more information.\n * \n * \\@stable\n */\nexport class RouterState extends Tree<ActivatedRoute> {\n/**\n * \\@internal\n * @param {?} root\n * @param {?} snapshot\n */\nconstructor(\n      root: TreeNode<ActivatedRoute>,\npublic snapshot: RouterStateSnapshot) {\n    super(root);\n    setRouterState(<RouterState>this, root);\n  }\n/**\n * @return {?}\n */\ntoString(): string { return this.snapshot.toString(); }\n}\n\nfunction RouterState_tsickle_Closure_declarations() {\n/**\n * The current snapshot of the router state\n * @type {?}\n */\nRouterState.prototype.snapshot;\n}\n\n/**\n * @param {?} urlTree\n * @param {?} rootComponent\n * @return {?}\n */\nexport function createEmptyState(urlTree: UrlTree, rootComponent: Type<any>| null): RouterState {\n  const /** @type {?} */ snapshot = createEmptyStateSnapshot(urlTree, rootComponent);\n  const /** @type {?} */ emptyUrl = new BehaviorSubject([new UrlSegment('', {})]);\n  const /** @type {?} */ emptyParams = new BehaviorSubject({});\n  const /** @type {?} */ emptyData = new BehaviorSubject({});\n  const /** @type {?} */ emptyQueryParams = new BehaviorSubject({});\n  const /** @type {?} */ fragment = new BehaviorSubject('');\n  const /** @type {?} */ activated = new ActivatedRoute(\n      emptyUrl, emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent,\n      snapshot.root);\n  activated.snapshot = snapshot.root;\n  return new RouterState(new TreeNode<ActivatedRoute>(activated, []), snapshot);\n}\n/**\n * @param {?} urlTree\n * @param {?} rootComponent\n * @return {?}\n */\nexport function createEmptyStateSnapshot(\n    urlTree: UrlTree, rootComponent: Type<any>| null): RouterStateSnapshot {\n  const /** @type {?} */ emptyParams = {};\n  const /** @type {?} */ emptyData = {};\n  const /** @type {?} */ emptyQueryParams = {};\n  const /** @type {?} */ fragment = '';\n  const /** @type {?} */ activated = new ActivatedRouteSnapshot(\n      [], emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, null,\n      urlTree.root, -1, {});\n  return new RouterStateSnapshot('', new TreeNode<ActivatedRouteSnapshot>(activated, []));\n}\n/**\n * \\@whatItDoes Contains the information about a route associated with a component loaded in an\n * outlet.\n * An `ActivatedRoute` can also be used to traverse the router state tree.\n * \n * \\@howToUse \n * \n * ```\n * \\@Component({...}) \n * class MyComponent {\n *   constructor(route: ActivatedRoute) {\n *     const id: Observable<string> = route.params.map(p => p.id);\n *     const url: Observable<string> = 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 * \\@stable\n */\nexport class ActivatedRoute {\n/**\n * The current snapshot of this route\n */\nsnapshot: ActivatedRouteSnapshot;\n/**\n * \\@internal\n */\n_futureSnapshot: ActivatedRouteSnapshot;\n/**\n * \\@internal\n */\n_routerState: RouterState;\n/**\n * \\@internal\n */\n_paramMap: Observable<ParamMap>;\n/**\n * \\@internal\n */\n_queryParamMap: Observable<ParamMap>;\n/**\n * \\@internal\n * @param {?} url\n * @param {?} params\n * @param {?} queryParams\n * @param {?} fragment\n * @param {?} data\n * @param {?} outlet\n * @param {?} component\n * @param {?} futureSnapshot\n */\nconstructor(\npublic url: Observable<UrlSegment[]>,\npublic params: Observable<Params>,\npublic queryParams: Observable<Params>,\npublic fragment: Observable<string>,\npublic data: Observable<Data>,\npublic outlet: string,\npublic component: Type<any>|string|null, futureSnapshot: ActivatedRouteSnapshot) {\n    this._futureSnapshot = futureSnapshot;\n  }\n/**\n * The configuration used to match this route\n * @return {?}\n */\nget routeConfig(): Route|null { return this._futureSnapshot.routeConfig; }\n/**\n * The root of the router state\n * @return {?}\n */\nget root(): ActivatedRoute { return this._routerState.root; }\n/**\n * The parent of this route in the router state tree\n * @return {?}\n */\nget parent(): ActivatedRoute|null { return this._routerState.parent(this); }\n/**\n * The first child of this route in the router state tree\n * @return {?}\n */\nget firstChild(): ActivatedRoute|null { return this._routerState.firstChild(this); }\n/**\n * The children of this route in the router state tree\n * @return {?}\n */\nget children(): ActivatedRoute[] { return this._routerState.children(this); }\n/**\n * The path from the root of the router state tree to this route\n * @return {?}\n */\nget pathFromRoot(): ActivatedRoute[] { return this._routerState.pathFromRoot(this); }\n/**\n * @return {?}\n */\nget paramMap(): Observable<ParamMap> {\n    if (!this._paramMap) {\n      this._paramMap = map.call(this.params, (p: Params): ParamMap => convertToParamMap(p));\n    }\n    return this._paramMap;\n  }\n/**\n * @return {?}\n */\nget queryParamMap(): Observable<ParamMap> {\n    if (!this._queryParamMap) {\n      this._queryParamMap =\n          map.call(this.queryParams, (p: Params): ParamMap => convertToParamMap(p));\n    }\n    return this._queryParamMap;\n  }\n/**\n * @return {?}\n */\ntoString(): string {\n    return this.snapshot ? this.snapshot.toString() : `Future(${this._futureSnapshot})`;\n  }\n}\n\nfunction ActivatedRoute_tsickle_Closure_declarations() {\n/**\n * The current snapshot of this route\n * @type {?}\n */\nActivatedRoute.prototype.snapshot;\n/**\n * \\@internal\n * @type {?}\n */\nActivatedRoute.prototype._futureSnapshot;\n/**\n * \\@internal\n * @type {?}\n */\nActivatedRoute.prototype._routerState;\n/**\n * \\@internal\n * @type {?}\n */\nActivatedRoute.prototype._paramMap;\n/**\n * \\@internal\n * @type {?}\n */\nActivatedRoute.prototype._queryParamMap;\n/**\n * An observable of the URL segments matched by this route\n * @type {?}\n */\nActivatedRoute.prototype.url;\n/**\n * An observable of the matrix parameters scoped to this route\n * @type {?}\n */\nActivatedRoute.prototype.params;\n/**\n * An observable of the query parameters shared by all the routes\n * @type {?}\n */\nActivatedRoute.prototype.queryParams;\n/**\n * An observable of the URL fragment shared by all the routes\n * @type {?}\n */\nActivatedRoute.prototype.fragment;\n/**\n * An observable of the static and resolved data of this route.\n * @type {?}\n */\nActivatedRoute.prototype.data;\n/**\n * The outlet name of the route. It's a constant\n * @type {?}\n */\nActivatedRoute.prototype.outlet;\n/** @type {?} */\nActivatedRoute.prototype.component;\n}\n\n\n/** @internal */\nexport type Inherited = {\n  params: Params,\n  data: Data,\n  resolve: Data,\n};\n/**\n * \\@internal\n * @param {?} route\n * @return {?}\n */\nexport function inheritedParamsDataResolve(route: ActivatedRouteSnapshot): Inherited {\n  const /** @type {?} */ pathToRoot = route.pathFromRoot;\n\n  let /** @type {?} */ inhertingStartingFrom = pathToRoot.length - 1;\n\n  while (inhertingStartingFrom >= 1) {\n    const /** @type {?} */ current = pathToRoot[inhertingStartingFrom];\n    const /** @type {?} */ parent = pathToRoot[inhertingStartingFrom - 1];\n    // current route is an empty path => inherits its parent's params and data\n    if (current.routeConfig && current.routeConfig.path === '') {\n      inhertingStartingFrom--;\n\n      // parent is componentless => current route should inherit its params and data\n    } else if (!parent.component) {\n      inhertingStartingFrom--;\n\n    } else {\n      break;\n    }\n  }\n\n  return pathToRoot.slice(inhertingStartingFrom).reduce((res, curr) => {\n    const /** @type {?} */ params = {...res.params, ...curr.params};\n    const /** @type {?} */ data = {...res.data, ...curr.data};\n    const /** @type {?} */ resolve = {...res.resolve, ...curr._resolvedData};\n    return {params, data, resolve};\n  }, /** @type {?} */(( <any>{params: {}, data: {}, resolve: {}})));\n}\n/**\n * \\@whatItDoes Contains the information about a route associated with a component loaded in an\n * outlet\n * at a particular moment in time. ActivatedRouteSnapshot can also be used to traverse the router\n * state tree.\n * \n * \\@howToUse \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 * \\@stable\n */\nexport class ActivatedRouteSnapshot {\n/**\n * \\@internal *\n */\n_routeConfig: Route|null;\n/**\n * \\@internal *\n */\n_urlSegment: UrlSegmentGroup;\n/**\n * \\@internal\n */\n_lastPathIndex: number;\n/**\n * \\@internal\n */\n_resolve: ResolveData;\n/**\n * \\@internal\n */\n_resolvedData: Data;\n/**\n * \\@internal\n */\n_routerState: RouterStateSnapshot;\n/**\n * \\@internal\n */\n_paramMap: ParamMap;\n/**\n * \\@internal\n */\n_queryParamMap: ParamMap;\n/**\n * \\@internal\n * @param {?} url\n * @param {?} params\n * @param {?} queryParams\n * @param {?} fragment\n * @param {?} data\n * @param {?} outlet\n * @param {?} component\n * @param {?} routeConfig\n * @param {?} urlSegment\n * @param {?} lastPathIndex\n * @param {?} resolve\n */\nconstructor(\npublic url: UrlSegment[],\npublic params: Params,\npublic queryParams: Params,\npublic fragment: string,\npublic data: Data,\npublic outlet: string,\npublic component: Type<any>|string|null, routeConfig: Route|null, urlSegment: UrlSegmentGroup,\n      lastPathIndex: number, resolve: ResolveData) {\n    this._routeConfig = routeConfig;\n    this._urlSegment = urlSegment;\n    this._lastPathIndex = lastPathIndex;\n    this._resolve = resolve;\n  }\n/**\n * The configuration used to match this route\n * @return {?}\n */\nget routeConfig(): Route|null { return this._routeConfig; }\n/**\n * The root of the router state\n * @return {?}\n */\nget root(): ActivatedRouteSnapshot { return this._routerState.root; }\n/**\n * The parent of this route in the router state tree\n * @return {?}\n */\nget parent(): ActivatedRouteSnapshot|null { return this._routerState.parent(this); }\n/**\n * The first child of this route in the router state tree\n * @return {?}\n */\nget firstChild(): ActivatedRouteSnapshot|null { return this._routerState.firstChild(this); }\n/**\n * The children of this route in the router state tree\n * @return {?}\n */\nget children(): ActivatedRouteSnapshot[] { return this._routerState.children(this); }\n/**\n * The path from the root of the router state tree to this route\n * @return {?}\n */\nget pathFromRoot(): ActivatedRouteSnapshot[] { return this._routerState.pathFromRoot(this); }\n/**\n * @return {?}\n */\nget paramMap(): ParamMap {\n    if (!this._paramMap) {\n      this._paramMap = convertToParamMap(this.params);\n    }\n    return this._paramMap;\n  }\n/**\n * @return {?}\n */\nget queryParamMap(): ParamMap {\n    if (!this._queryParamMap) {\n      this._queryParamMap = convertToParamMap(this.queryParams);\n    }\n    return this._queryParamMap;\n  }\n/**\n * @return {?}\n */\ntoString(): string {\n    const /** @type {?} */ url = this.url.map(segment => segment.toString()).join('/');\n    const /** @type {?} */ matched = this._routeConfig ? this._routeConfig.path : '';\n    return `Route(url:'${url}', path:'${matched}')`;\n  }\n}\n\nfunction ActivatedRouteSnapshot_tsickle_Closure_declarations() {\n/**\n * \\@internal *\n * @type {?}\n */\nActivatedRouteSnapshot.prototype._routeConfig;\n/**\n * \\@internal *\n * @type {?}\n */\nActivatedRouteSnapshot.prototype._urlSegment;\n/**\n * \\@internal\n * @type {?}\n */\nActivatedRouteSnapshot.prototype._lastPathIndex;\n/**\n * \\@internal\n * @type {?}\n */\nActivatedRouteSnapshot.prototype._resolve;\n/**\n * \\@internal\n * @type {?}\n */\nActivatedRouteSnapshot.prototype._resolvedData;\n/**\n * \\@internal\n * @type {?}\n */\nActivatedRouteSnapshot.prototype._routerState;\n/**\n * \\@internal\n * @type {?}\n */\nActivatedRouteSnapshot.prototype._paramMap;\n/**\n * \\@internal\n * @type {?}\n */\nActivatedRouteSnapshot.prototype._queryParamMap;\n/**\n * The URL segments matched by this route\n * @type {?}\n */\nActivatedRouteSnapshot.prototype.url;\n/**\n * The matrix parameters scoped to this route\n * @type {?}\n */\nActivatedRouteSnapshot.prototype.params;\n/**\n * The query parameters shared by all the routes\n * @type {?}\n */\nActivatedRouteSnapshot.prototype.queryParams;\n/**\n * The URL fragment shared by all the routes\n * @type {?}\n */\nActivatedRouteSnapshot.prototype.fragment;\n/**\n * The static and resolved data of this route\n * @type {?}\n */\nActivatedRouteSnapshot.prototype.data;\n/**\n * The outlet name of the route\n * @type {?}\n */\nActivatedRouteSnapshot.prototype.outlet;\n/**\n * The component of the route\n * @type {?}\n */\nActivatedRouteSnapshot.prototype.component;\n}\n\n/**\n * \\@whatItDoes Represents the state of the router at a moment in time.\n * \n * \\@howToUse \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<string> = child.params.map(p => p.id);\n *     //...\n *   }\n * }\n * ```\n * \n * \\@description \n * RouterStateSnapshot 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 * \\@stable\n */\nexport class RouterStateSnapshot extends Tree<ActivatedRouteSnapshot> {\n/**\n * \\@internal\n * @param {?} url\n * @param {?} root\n */\nconstructor(\npublic url: string, root: TreeNode<ActivatedRouteSnapshot>) {\n    super(root);\n    setRouterState(<RouterStateSnapshot>this, root);\n  }\n/**\n * @return {?}\n */\ntoString(): string { return serializeNode(this._root); }\n}\n\nfunction RouterStateSnapshot_tsickle_Closure_declarations() {\n/**\n * The url from which this snapshot was created\n * @type {?}\n */\nRouterStateSnapshot.prototype.url;\n}\n\n/**\n * @template U, T\n * @param {?} state\n * @param {?} node\n * @return {?}\n */\nfunction setRouterState<U, T extends{_routerState: U}>(state: U, node: TreeNode<T>): void {\n  node.value._routerState = state;\n  node.children.forEach(c => setRouterState(state, c));\n}\n/**\n * @param {?} node\n * @return {?}\n */\nfunction serializeNode(node: TreeNode<ActivatedRouteSnapshot>): string {\n  const /** @type {?} */ 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 * @param {?} route\n * @return {?}\n */\nexport function advanceActivatedRoute(route: ActivatedRoute): void {\n  if (route.snapshot) {\n    const /** @type {?} */ currentSnapshot = route.snapshot;\n    const /** @type {?} */ nextSnapshot = route._futureSnapshot;\n    route.snapshot = nextSnapshot;\n    if (!shallowEqual(currentSnapshot.queryParams, nextSnapshot.queryParams)) {\n      ( /** @type {?} */((<any>route.queryParams))).next(nextSnapshot.queryParams);\n    }\n    if (currentSnapshot.fragment !== nextSnapshot.fragment) {\n      ( /** @type {?} */((<any>route.fragment))).next(nextSnapshot.fragment);\n    }\n    if (!shallowEqual(currentSnapshot.params, nextSnapshot.params)) {\n      ( /** @type {?} */((<any>route.params))).next(nextSnapshot.params);\n    }\n    if (!shallowEqualArrays(currentSnapshot.url, nextSnapshot.url)) {\n      ( /** @type {?} */((<any>route.url))).next(nextSnapshot.url);\n    }\n    if (!shallowEqual(currentSnapshot.data, nextSnapshot.data)) {\n      ( /** @type {?} */((<any>route.data))).next(nextSnapshot.data);\n    }\n  } else {\n    route.snapshot = route._futureSnapshot;\n\n    // this is for resolved data\n    ( /** @type {?} */((<any>route.data))).next(route._futureSnapshot.data);\n  }\n}\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nexport function equalParamsAndUrlSegments(\n    a: ActivatedRouteSnapshot, b: ActivatedRouteSnapshot): boolean {\n  const /** @type {?} */ equalUrlParams = shallowEqual(a.params, b.params) && equalSegments(a.url, b.url);\n  const /** @type {?} */ parentsMismatch = !a.parent !== !b.parent;\n\n  return equalUrlParams && !parentsMismatch &&\n      (!a.parent || equalParamsAndUrlSegments(a.parent, /** @type {?} */(( b.parent))));\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\nimport {ActivatedRoute} from './router_state';\nimport {PRIMARY_OUTLET, Params} from './shared';\nimport {UrlSegment, UrlSegmentGroup, UrlTree} from './url_tree';\nimport {forEach, last, shallowEqual} from './utils/collection';\n/**\n * @param {?} route\n * @param {?} urlTree\n * @param {?} commands\n * @param {?} queryParams\n * @param {?} fragment\n * @return {?}\n */\nexport function createUrlTree(\n    route: ActivatedRoute, urlTree: UrlTree, commands: any[], queryParams: Params,\n    fragment: string): UrlTree {\n  if (commands.length === 0) {\n    return tree(urlTree.root, urlTree.root, urlTree, queryParams, fragment);\n  }\n\n  const /** @type {?} */ nav = computeNavigation(commands);\n\n  if (nav.toRoot()) {\n    return tree(urlTree.root, new UrlSegmentGroup([], {}), urlTree, queryParams, fragment);\n  }\n\n  const /** @type {?} */ startingPosition = findStartingPosition(nav, urlTree, route);\n\n  const /** @type {?} */ segmentGroup = startingPosition.processChildren ?\n      updateSegmentGroupChildren(\n          startingPosition.segmentGroup, startingPosition.index, nav.commands) :\n      updateSegmentGroup(startingPosition.segmentGroup, startingPosition.index, nav.commands);\n  return tree(startingPosition.segmentGroup, segmentGroup, urlTree, queryParams, fragment);\n}\n/**\n * @param {?} command\n * @return {?}\n */\nfunction isMatrixParams(command: any): boolean {\n  return typeof command === 'object' && command != null && !command.outlets && !command.segmentPath;\n}\n/**\n * @param {?} oldSegmentGroup\n * @param {?} newSegmentGroup\n * @param {?} urlTree\n * @param {?} queryParams\n * @param {?} fragment\n * @return {?}\n */\nfunction tree(\n    oldSegmentGroup: UrlSegmentGroup, newSegmentGroup: UrlSegmentGroup, urlTree: UrlTree,\n    queryParams: Params, fragment: string): UrlTree {\n  let /** @type {?} */ qp: any = {};\n  if (queryParams) {\n    forEach(queryParams, (value: any, name: any) => {\n      qp[name] = Array.isArray(value) ? value.map((v: any) => `${v}`) : `${value}`;\n    });\n  }\n\n  if (urlTree.root === oldSegmentGroup) {\n    return new UrlTree(newSegmentGroup, qp, fragment);\n  }\n\n  return new UrlTree(replaceSegment(urlTree.root, oldSegmentGroup, newSegmentGroup), qp, fragment);\n}\n/**\n * @param {?} current\n * @param {?} oldSegment\n * @param {?} newSegment\n * @return {?}\n */\nfunction replaceSegment(\n    current: UrlSegmentGroup, oldSegment: UrlSegmentGroup,\n    newSegment: UrlSegmentGroup): UrlSegmentGroup {\n  const /** @type {?} */ children: {[key: string]: UrlSegmentGroup} = {};\n  forEach(current.children, (c: UrlSegmentGroup, outletName: string) => {\n    if (c === oldSegment) {\n      children[outletName] = newSegment;\n    } else {\n      children[outletName] = replaceSegment(c, oldSegment, newSegment);\n    }\n  });\n  return new UrlSegmentGroup(current.segments, children);\n}\nclass Navigation {\n/**\n * @param {?} isAbsolute\n * @param {?} numberOfDoubleDots\n * @param {?} commands\n */\nconstructor(\npublic isAbsolute: boolean,\npublic numberOfDoubleDots: number,\npublic commands: any[]) {\n    if (isAbsolute && commands.length > 0 && isMatrixParams(commands[0])) {\n      throw new Error('Root segment cannot have matrix parameters');\n    }\n\n    const cmdWithOutlet = commands.find(c => typeof c === 'object' && c != null && c.outlets);\n    if (cmdWithOutlet && cmdWithOutlet !== last(commands)) {\n      throw new Error('{outlets:{}} has to be the last command');\n    }\n  }\n/**\n * @return {?}\n */\npublic toRoot(): boolean {\n    return this.isAbsolute && this.commands.length === 1 && this.commands[0] == '/';\n  }\n}\n\nfunction Navigation_tsickle_Closure_declarations() {\n/** @type {?} */\nNavigation.prototype.isAbsolute;\n/** @type {?} */\nNavigation.prototype.numberOfDoubleDots;\n/** @type {?} */\nNavigation.prototype.commands;\n}\n\n/**\n * Transforms commands to a normalized `Navigation`\n * @param {?} commands\n * @return {?}\n */\nfunction computeNavigation(commands: any[]): Navigation {\n  if ((typeof commands[0] === 'string') && commands.length === 1 && commands[0] === '/') {\n    return new Navigation(true, 0, commands);\n  }\n\n  let /** @type {?} */ numberOfDoubleDots = 0;\n  let /** @type {?} */ isAbsolute = false;\n\n  const /** @type {?} */ res: any[] = commands.reduce((res, cmd, cmdIdx) => {\n    if (typeof cmd === 'object' && cmd != null) {\n      if (cmd.outlets) {\n        const /** @type {?} */ outlets: {[k: string]: any} = {};\n        forEach(cmd.outlets, (commands: any, name: string) => {\n          outlets[name] = typeof commands === 'string' ? commands.split('/') : commands;\n        });\n        return [...res, {outlets}];\n      }\n\n      if (cmd.segmentPath) {\n        return [...res, cmd.segmentPath];\n      }\n    }\n\n    if (!(typeof cmd === 'string')) {\n      return [...res, cmd];\n    }\n\n    if (cmdIdx === 0) {\n      cmd.split('/').forEach((urlPart, partIndex) => {\n        if (partIndex == 0 && urlPart === '.') {\n          // skip './a'\n        } else if (partIndex == 0 && urlPart === '') {  //  '/a'\n          isAbsolute = true;\n        } else if (urlPart === '..') {  //  '../a'\n          numberOfDoubleDots++;\n        } else if (urlPart != '') {\n          res.push(urlPart);\n        }\n      });\n\n      return res;\n    }\n\n    return [...res, cmd];\n  }, []);\n\n  return new Navigation(isAbsolute, numberOfDoubleDots, res);\n}\nclass Position {\n/**\n * @param {?} segmentGroup\n * @param {?} processChildren\n * @param {?} index\n */\nconstructor(\npublic segmentGroup: UrlSegmentGroup,\npublic processChildren: boolean,\npublic index: number) {\n  }\n}\n\nfunction Position_tsickle_Closure_declarations() {\n/** @type {?} */\nPosition.prototype.segmentGroup;\n/** @type {?} */\nPosition.prototype.processChildren;\n/** @type {?} */\nPosition.prototype.index;\n}\n\n/**\n * @param {?} nav\n * @param {?} tree\n * @param {?} route\n * @return {?}\n */\nfunction findStartingPosition(nav: Navigation, tree: UrlTree, route: ActivatedRoute): Position {\n  if (nav.isAbsolute) {\n    return new Position(tree.root, true, 0);\n  }\n\n  if (route.snapshot._lastPathIndex === -1) {\n    return new Position(route.snapshot._urlSegment, true, 0);\n  }\n\n  const /** @type {?} */ modifier = isMatrixParams(nav.commands[0]) ? 0 : 1;\n  const /** @type {?} */ index = route.snapshot._lastPathIndex + modifier;\n  return createPositionApplyingDoubleDots(\n      route.snapshot._urlSegment, index, nav.numberOfDoubleDots);\n}\n/**\n * @param {?} group\n * @param {?} index\n * @param {?} numberOfDoubleDots\n * @return {?}\n */\nfunction createPositionApplyingDoubleDots(\n    group: UrlSegmentGroup, index: number, numberOfDoubleDots: number): Position {\n  let /** @type {?} */ g = group;\n  let /** @type {?} */ ci = index;\n  let /** @type {?} */ dd = numberOfDoubleDots;\n  while (dd > ci) {\n    dd -= ci;\n    g = /** @type {?} */(( 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}\n/**\n * @param {?} command\n * @return {?}\n */\nfunction getPath(command: any): any {\n  if (typeof command === 'object' && command != null && command.outlets) {\n    return command.outlets[PRIMARY_OUTLET];\n  }\n  return `${command}`;\n}\n/**\n * @param {?} commands\n * @return {?}\n */\nfunction getOutlets(commands: any[]): {[k: string]: any[]} {\n  if (!(typeof commands[0] === 'object')) return {[PRIMARY_OUTLET]: commands};\n  if (commands[0].outlets === undefined) return {[PRIMARY_OUTLET]: commands};\n  return commands[0].outlets;\n}\n/**\n * @param {?} segmentGroup\n * @param {?} startIndex\n * @param {?} commands\n * @return {?}\n */\nfunction updateSegmentGroup(\n    segmentGroup: UrlSegmentGroup, startIndex: number, commands: any[]): UrlSegmentGroup {\n  if (!segmentGroup) {\n    segmentGroup = new UrlSegmentGroup([], {});\n  }\n  if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {\n    return updateSegmentGroupChildren(segmentGroup, startIndex, commands);\n  }\n\n  const /** @type {?} */ m = prefixedWith(segmentGroup, startIndex, commands);\n  const /** @type {?} */ slicedCommands = commands.slice(m.commandIndex);\n  if (m.match && m.pathIndex < segmentGroup.segments.length) {\n    const /** @type {?} */ 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  } else if (m.match && slicedCommands.length === 0) {\n    return new UrlSegmentGroup(segmentGroup.segments, {});\n  } else if (m.match && !segmentGroup.hasChildren()) {\n    return createNewSegmentGroup(segmentGroup, startIndex, commands);\n  } else if (m.match) {\n    return updateSegmentGroupChildren(segmentGroup, 0, slicedCommands);\n  } else {\n    return createNewSegmentGroup(segmentGroup, startIndex, commands);\n  }\n}\n/**\n * @param {?} segmentGroup\n * @param {?} startIndex\n * @param {?} commands\n * @return {?}\n */\nfunction updateSegmentGroupChildren(\n    segmentGroup: UrlSegmentGroup, startIndex: number, commands: any[]): UrlSegmentGroup {\n  if (commands.length === 0) {\n    return new UrlSegmentGroup(segmentGroup.segments, {});\n  } else {\n    const /** @type {?} */ outlets = getOutlets(commands);\n    const /** @type {?} */ children: {[key: string]: UrlSegmentGroup} = {};\n\n    forEach(outlets, (commands: any, outlet: string) => {\n      if (commands !== null) {\n        children[outlet] = updateSegmentGroup(segmentGroup.children[outlet], startIndex, commands);\n      }\n    });\n\n    forEach(segmentGroup.children, (child: UrlSegmentGroup, childOutlet: string) => {\n      if (outlets[childOutlet] === undefined) {\n        children[childOutlet] = child;\n      }\n    });\n    return new UrlSegmentGroup(segmentGroup.segments, children);\n  }\n}\n/**\n * @param {?} segmentGroup\n * @param {?} startIndex\n * @param {?} commands\n * @return {?}\n */\nfunction prefixedWith(segmentGroup: UrlSegmentGroup, startIndex: number, commands: any[]) {\n  let /** @type {?} */ currentCommandIndex = 0;\n  let /** @type {?} */ currentPathIndex = startIndex;\n\n  const /** @type {?} */ noMatch = {match: false, pathIndex: 0, commandIndex: 0};\n  while (currentPathIndex < segmentGroup.segments.length) {\n    if (currentCommandIndex >= commands.length) return noMatch;\n    const /** @type {?} */ path = segmentGroup.segments[currentPathIndex];\n    const /** @type {?} */ curr = getPath(commands[currentCommandIndex]);\n    const /** @type {?} */ next =\n        currentCommandIndex < commands.length - 1 ? commands[currentCommandIndex + 1] : null;\n\n    if (currentPathIndex > 0 && curr === undefined) break;\n\n    if (curr && next && (typeof next === 'object') && next.outlets === undefined) {\n      if (!compare(curr, next, path)) return noMatch;\n      currentCommandIndex += 2;\n    } else {\n      if (!compare(curr, {}, path)) return noMatch;\n      currentCommandIndex++;\n    }\n    currentPathIndex++;\n  }\n\n  return {match: true, pathIndex: currentPathIndex, commandIndex: currentCommandIndex};\n}\n/**\n * @param {?} segmentGroup\n * @param {?} startIndex\n * @param {?} commands\n * @return {?}\n */\nfunction createNewSegmentGroup(\n    segmentGroup: UrlSegmentGroup, startIndex: number, commands: any[]): UrlSegmentGroup {\n  const /** @type {?} */ paths = segmentGroup.segments.slice(0, startIndex);\n\n  let /** @type {?} */ i = 0;\n  while (i < commands.length) {\n    if (typeof commands[i] === 'object' && commands[i].outlets !== undefined) {\n      const /** @type {?} */ children = createNewSegmentChildren(commands[i].outlets);\n      return new UrlSegmentGroup(paths, children);\n    }\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      const /** @type {?} */ p = segmentGroup.segments[startIndex];\n      paths.push(new UrlSegment(p.path, commands[0]));\n      i++;\n      continue;\n    }\n\n    const /** @type {?} */ curr = getPath(commands[i]);\n    const /** @type {?} */ 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    } else {\n      paths.push(new UrlSegment(curr, {}));\n      i++;\n    }\n  }\n  return new UrlSegmentGroup(paths, {});\n}\n/**\n * @param {?} outlets\n * @return {?}\n */\nfunction createNewSegmentChildren(outlets: {[name: string]: any}): any {\n  const /** @type {?} */ children: {[key: string]: UrlSegmentGroup} = {};\n  forEach(outlets, (commands: any, outlet: string) => {\n    if (commands !== null) {\n      children[outlet] = createNewSegmentGroup(new UrlSegmentGroup([], {}), 0, commands);\n    }\n  });\n  return children;\n}\n/**\n * @param {?} params\n * @return {?}\n */\nfunction stringify(params: {[key: string]: any}): {[key: string]: string} {\n  const /** @type {?} */ res: {[key: string]: string} = {};\n  forEach(params, (v: any, k: string) => res[k] = `${v}`);\n  return res;\n}\n/**\n * @param {?} path\n * @param {?} params\n * @param {?} segment\n * @return {?}\n */\nfunction compare(path: string, params: {[key: string]: any}, segment: UrlSegment): boolean {\n  return path == segment.path && shallowEqual(params, segment.parameters);\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\nimport {BehaviorSubject} from 'rxjs/BehaviorSubject';\n\nimport {DetachedRouteHandleInternal, RouteReuseStrategy} from './route_reuse_strategy';\nimport {ActivatedRoute, ActivatedRouteSnapshot, RouterState, RouterStateSnapshot} from './router_state';\nimport {TreeNode} from './utils/tree';\n/**\n * @param {?} routeReuseStrategy\n * @param {?} curr\n * @param {?} prevState\n * @return {?}\n */\nexport function createRouterState(\n    routeReuseStrategy: RouteReuseStrategy, curr: RouterStateSnapshot,\n    prevState: RouterState): RouterState {\n  const /** @type {?} */ root = createNode(routeReuseStrategy, curr._root, prevState ? prevState._root : undefined);\n  return new RouterState(root, curr);\n}\n/**\n * @param {?} routeReuseStrategy\n * @param {?} curr\n * @param {?=} prevState\n * @return {?}\n */\nfunction createNode(\n    routeReuseStrategy: RouteReuseStrategy, curr: TreeNode<ActivatedRouteSnapshot>,\n    prevState?: TreeNode<ActivatedRoute>): TreeNode<ActivatedRoute> {\n  // reuse an activated route that is currently displayed on the screen\n  if (prevState && routeReuseStrategy.shouldReuseRoute(curr.value, prevState.value.snapshot)) {\n    const /** @type {?} */ value = prevState.value;\n    value._futureSnapshot = curr.value;\n    const /** @type {?} */ children = createOrReuseChildren(routeReuseStrategy, curr, prevState);\n    return new TreeNode<ActivatedRoute>(value, children);\n\n    // retrieve an activated route that is used to be displayed, but is not currently displayed\n  } else if (routeReuseStrategy.retrieve(curr.value)) {\n    const /** @type {?} */ tree: TreeNode<ActivatedRoute> =\n        ( /** @type {?} */((<DetachedRouteHandleInternal>routeReuseStrategy.retrieve(curr.value)))).route;\n    setFutureSnapshotsOfActivatedRoutes(curr, tree);\n    return tree;\n\n  } else {\n    const /** @type {?} */ value = createActivatedRoute(curr.value);\n    const /** @type {?} */ children = curr.children.map(c => createNode(routeReuseStrategy, c));\n    return new TreeNode<ActivatedRoute>(value, children);\n  }\n}\n/**\n * @param {?} curr\n * @param {?} result\n * @return {?}\n */\nfunction setFutureSnapshotsOfActivatedRoutes(\n    curr: TreeNode<ActivatedRouteSnapshot>, result: TreeNode<ActivatedRoute>): void {\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 (let /** @type {?} */ i = 0; i < curr.children.length; ++i) {\n    setFutureSnapshotsOfActivatedRoutes(curr.children[i], result.children[i]);\n  }\n}\n/**\n * @param {?} routeReuseStrategy\n * @param {?} curr\n * @param {?} prevState\n * @return {?}\n */\nfunction createOrReuseChildren(\n    routeReuseStrategy: RouteReuseStrategy, curr: TreeNode<ActivatedRouteSnapshot>,\n    prevState: TreeNode<ActivatedRoute>) {\n  return curr.children.map(child => {\n    for (const /** @type {?} */ p of prevState.children) {\n      if (routeReuseStrategy.shouldReuseRoute(p.value.snapshot, child.value)) {\n        return createNode(routeReuseStrategy, child, p);\n      }\n    }\n    return createNode(routeReuseStrategy, child);\n  });\n}\n/**\n * @param {?} c\n * @return {?}\n */\nfunction createActivatedRoute(c: ActivatedRouteSnapshot) {\n  return new ActivatedRoute(\n      new BehaviorSubject(c.url), new BehaviorSubject(c.params), new BehaviorSubject(c.queryParams),\n      new BehaviorSubject(c.fragment), new BehaviorSubject(c.data), c.outlet, c.component, c);\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 */\nexport class Tree<T> {\n/**\n * \\@internal\n */\n_root: TreeNode<T>;\n/**\n * @param {?} root\n */\nconstructor(root: TreeNode<T>) { this._root = root; }\n/**\n * @return {?}\n */\nget root(): T { return this._root.value; }\n/**\n * \\@internal\n * @param {?} t\n * @return {?}\n */\nparent(t: T): T|null {\n    const /** @type {?} */ p = this.pathFromRoot(t);\n    return p.length > 1 ? p[p.length - 2] : null;\n  }\n/**\n * \\@internal\n * @param {?} t\n * @return {?}\n */\nchildren(t: T): T[] {\n    const /** @type {?} */ n = findNode(t, this._root);\n    return n ? n.children.map(t => t.value) : [];\n  }\n/**\n * \\@internal\n * @param {?} t\n * @return {?}\n */\nfirstChild(t: T): T|null {\n    const /** @type {?} */ n = findNode(t, this._root);\n    return n && n.children.length > 0 ? n.children[0].value : null;\n  }\n/**\n * \\@internal\n * @param {?} t\n * @return {?}\n */\nsiblings(t: T): T[] {\n    const /** @type {?} */ p = findPath(t, this._root);\n    if (p.length < 2) return [];\n\n    const /** @type {?} */ c = p[p.length - 2].children.map(c => c.value);\n    return c.filter(cc => cc !== t);\n  }\n/**\n * \\@internal\n * @param {?} t\n * @return {?}\n */\npathFromRoot(t: T): T[] { return findPath(t, this._root).map(s => s.value); }\n}\n\nfunction Tree_tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\nTree.prototype._root;\n}\n\n/**\n * @template T\n * @param {?} value\n * @param {?} node\n * @return {?}\n */\nfunction findNode<T>(value: T, node: TreeNode<T>): TreeNode<T>|null {\n  if (value === node.value) return node;\n\n  for (const /** @type {?} */ child of node.children) {\n    const /** @type {?} */ node = findNode(value, child);\n    if (node) return node;\n  }\n\n  return null;\n}\n/**\n * @template T\n * @param {?} value\n * @param {?} node\n * @return {?}\n */\nfunction findPath<T>(value: T, node: TreeNode<T>): TreeNode<T>[] {\n  if (value === node.value) return [node];\n\n  for (const /** @type {?} */ child of node.children) {\n    const /** @type {?} */ path = findPath(value, child);\n    if (path.length) {\n      path.unshift(node);\n      return path;\n    }\n  }\n\n  return [];\n}\nexport class TreeNode<T> {\n/**\n * @param {?} value\n * @param {?} children\n */\nconstructor(public value: T,\npublic children: TreeNode<T>[]) {}\n/**\n * @return {?}\n */\ntoString(): string { return `TreeNode(${this.value})`; }\n}\n\nfunction TreeNode_tsickle_Closure_declarations() {\n/** @type {?} */\nTreeNode.prototype.value;\n/** @type {?} */\nTreeNode.prototype.children;\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\nimport {NgModuleFactory, ɵisObservable as isObservable, ɵisPromise as isPromise} from '@angular/core';\nimport {Observable} from 'rxjs/Observable';\nimport {fromPromise} from 'rxjs/observable/fromPromise';\nimport {of } from 'rxjs/observable/of';\nimport {concatAll} from 'rxjs/operator/concatAll';\nimport {every} from 'rxjs/operator/every';\nimport * as l from 'rxjs/operator/last';\nimport {map} from 'rxjs/operator/map';\nimport {mergeAll} from 'rxjs/operator/mergeAll';\nimport {PRIMARY_OUTLET} from '../shared';\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nexport function shallowEqualArrays(a: any[], b: any[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let /** @type {?} */ i = 0; i < a.length; ++i) {\n    if (!shallowEqual(a[i], b[i])) return false;\n  }\n  return true;\n}\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nexport function shallowEqual(a: {[x: string]: any}, b: {[x: string]: any}): boolean {\n  const /** @type {?} */ k1 = Object.keys(a);\n  const /** @type {?} */ k2 = Object.keys(b);\n  if (k1.length != k2.length) {\n    return false;\n  }\n  let /** @type {?} */ key: string;\n  for (let /** @type {?} */ 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 * @template T\n * @param {?} arr\n * @return {?}\n */\nexport function flatten<T>(arr: T[][]): T[] {\n  return Array.prototype.concat.apply([], arr);\n}\n/**\n * @template T\n * @param {?} a\n * @return {?}\n */\nexport function last<T>(a: T[]): T|null {\n  return a.length > 0 ? a[a.length - 1] : null;\n}\n/**\n * @param {?} bools\n * @return {?}\n */\nexport function and(bools: boolean[]): boolean {\n  return !bools.some(v => !v);\n}\n/**\n * @template K, V\n * @param {?} map\n * @param {?} callback\n * @return {?}\n */\nexport function forEach<K, V>(map: {[key: string]: V}, callback: (v: V, k: string) => void): void {\n  for (const /** @type {?} */ prop in map) {\n    if (map.hasOwnProperty(prop)) {\n      callback(map[prop], prop);\n    }\n  }\n}\n/**\n * @template A, B\n * @param {?} obj\n * @param {?} fn\n * @return {?}\n */\nexport function waitForMap<A, B>(\n    obj: {[k: string]: A}, fn: (k: string, a: A) => Observable<B>): Observable<{[k: string]: B}> {\n  if (Object.keys(obj).length === 0) {\n    return of ({});\n  }\n\n  const /** @type {?} */ waitHead: Observable<B>[] = [];\n  const /** @type {?} */ waitTail: Observable<B>[] = [];\n  const /** @type {?} */ res: {[k: string]: B} = {};\n\n  forEach(obj, (a: A, k: string) => {\n    const /** @type {?} */ mapped = map.call(fn(k, a), (r: B) => res[k] = r);\n    if (k === PRIMARY_OUTLET) {\n      waitHead.push(mapped);\n    } else {\n      waitTail.push(mapped);\n    }\n  });\n\n  const /** @type {?} */ concat$ = concatAll.call(of (...waitHead, ...waitTail));\n  const /** @type {?} */ last$ = l.last.call(concat$);\n  return map.call(last$, () => res);\n}\n/**\n * @param {?} observables\n * @return {?}\n */\nexport function andObservables(observables: Observable<Observable<any>>): Observable<boolean> {\n  const /** @type {?} */ merged$ = mergeAll.call(observables);\n  return every.call(merged$, (result: any) => result === true);\n}\n/**\n * @template T\n * @param {?} value\n * @return {?}\n */\nexport function wrapIntoObservable<T>(value: T | NgModuleFactory<T>| Promise<T>| Observable<T>):\n    Observable<T> {\n  if (isObservable(value)) {\n    return value;\n  }\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 fromPromise(Promise.resolve(value));\n  }\n\n  return of ( /** @type {?} */((value as T)));\n}\n"],"names":["ROUTER_DIRECTIVES","RouterOutlet","RouterLink","RouterLinkWithHref","RouterLinkActive","ROUTER_CONFIGURATION","_angular_core","InjectionToken","ROUTER_FORROOT_GUARD","ROUTER_PROVIDERS","_angular_common","Location","ApplicationRef","DefaultUrlSerializer","provide","Router","useFactory","setupRouter","deps","UrlSerializer","ChildrenOutletContexts","Injector","NgModuleFactoryLoader","Compiler","ROUTES","UrlHandlingStrategy","Optional","RouteReuseStrategy","ActivatedRoute","rootRoute","useClass","SystemJsNgModuleLoader","RouterModule","forRoot","routes","config","ngModule","providers","provideRoutes","provideForRootGuard","SkipSelf","PlatformLocation","LocationStrategy","provideLocationStrategy","Inject","APP_BASE_HREF","this","resultOfPreactivationDone","rxjs_Subject","Subject","RouterInitializer","prototype","appInitializer","_this","injector","get","LOCATION_INITIALIZED","Promise","resolve","then","res","r","router","isLegacyDisabled","opts","isLegacyEnabled","initialNavigation","hooks","afterPreactivation","initNavigation","rxjs_observable_of","of","bootstrapListener","bootstrappedComponentRef","preloader","RouterPreloader","ref","components","ROUTER_INITIALIZER","resolver","onOutletReAttached","contexts","context","parentContexts","location","name","changeDetector","activated","onChildOutletCreated","ngOnDestroy","onChildOutletDestroyed","ngOnInit","getContext","route","activateWith","Object","defineProperty","Error","insert","hostView","activatedRoute","isActivated","_activatedRoute","snapshot","_futureSnapshot","component","childContexts","getOrCreateContext","children","OutletInjector","activateEvents","emit","instance","type","Directive","args","selector","exportAs","ctorParameters","token","processRoutes","loadChildren","canLoad","_loadedConfig","childConfig","preloadingStrategy","preload","loaded$","loader","load","Injectable","element","renderer","cdr","routerLinkActiveOptions","exact","s","NavigationEnd","ngAfterContentInit","classes","Array","isArray","data","split","subscription","unsubscribe","update","links","linksWithHrefs","navigated","hasActiveLinks","active","forEach","c","removeClass","nativeElement","link","isActive","urlTree","some","isLinkActive","decorators","Renderer2","propDecorators","target","HostBinding","Input","queryParams","fragment","replaceUrl","slicedSegments","length","segmentGroup","hasChildren","children_3","processChildren","TreeNode","DefaultRouteReuseStrategy","store","detachedTree","RouterConfigLoader","parentInjector","onLoadStartListener","onLoadEndListener","loadModuleFactory","rxjs_observable_fromPromise","fromPromise","rxjs_operator_mergeMap","mergeMap","call","wrapIntoObservable","t","defaultRouterHook","urlHandlingStrategy","DefaultUrlHandlingStrategy","routeReuseStrategy","resetRootComponentType","rootComponentType","setUpLocationChangeListener","rawUrlTree","urlSerializer","parse","change","source","dispose","createUrlTree","commands","navigationExtras","relativeTo","preserveQueryParams","queryParamsHandling","preserveFragment","isDevMode","console","warn","a","routerState","root","f","currentUrlTree","q","assign","url","UrlTree","value","params","key","undefined","processNavigations","navigations","nav","executeScheduledNavigation","lastNavigation","rawUrl","toString","reject","id","navigationId","_a","extras","extract","urlTransition","_","runNavigate","skipLocationChange","shouldProcessUrl","shouldPreventPushState","shouldReplaceUrl","precreatedState","resolvePromise","rejectPromise","urlAndSnapshot$","moduleInjector","redirectsApplied$","applyRedirects","configLoader","appliedUrl","rxjs_operator_map","map","recognize","serializeUrl","routerEvents","next","RoutesRecognized","preActivation","navigationIsSuccessful","beforePreactivationDone$","p","beforePreactivation","preactivationTraverse$","PreActivation","currentRouterState","traverse","rootContexts","preactivationCheckGuards$","triggerEvent","GuardsCheckStart","checkGuards","shouldActivate","GuardsCheckEnd","preactivationResolveData$","isActivating","ResolveStart","resolveData","ResolveEnd","preactivationDone$","state","createRouterState","storedState","storedUrl","routerState$","merge","path","serialize","isCurrentPathEqualTo","replaceState","go","ActivateRoutes","activate","resetUrlToCurrentUrlTree","NavigationCancel","e","isNavigationCancelingError","message","NavigationError","errorHandler","ee","CanActivate","enumerable","CanDeactivate","future","traverseChildRoutes","futureRoot","currRoot","isDeactivating","canDeactivate$","canDeactivate","runCanActivateChecks","futureNode","currNode","futurePath","traverseRoutes","curr","outlet","shouldRunGuardsAndResolvers","canDeactivateChecks","push","deactivateRouteAndItsChildren","canActivateChecks","mode","nodeChildrenAsMap","node","childName","runCanDeactivateChecks","runCanActivate","canActivate","_routeConfig","rxjs_observable_from","from","observable","guard","getToken","runCanActivateChild","canActivateChildGuards","slice","reverse","extractCanActivateChild","filter","andObservables","d","guards","canActivateChild","runCanDeactivate","resolveNode","keys","key_1","getResolver","deactivateChildRoutes","deactivateRoutes","parentContext","activateRoutes","advanceActivatedRoute","activateChildRoutes","shouldAttach","stored","retrieve","attachRef","componentRef","advanceActivatedRouteNodeAndItsChildren","cmpFactoryResolver","set","configurable","attrBoolValue","Attribute","ElementRef","locationStrategy","events","subscribe","onClick","button","ctrlKey","metaKey","shiftKey","map$$1","compiler","flatten","enableTracing","dom_1","log","provideRouterInitializer","APP_INITIALIZER","extendStatics","setPrototypeOf","__proto__","b","hasOwnProperty","urlAfterRedirects","RouteConfigLoadStart","RouteConfigLoadEnd","PRIMARY_OUTLET","ParamsAsMap","has","getAll","LoadedRouterConfig","module","UrlSegmentGroup","tree","encodeURI","consumeOptional","remaining","peekStartsWith","parseChildren","decodeURI","UrlParser","segments","parseSegment","capture","parseParens","matchSegments","UrlSegment","decode","parseMatrixParams","parseParam","valueMatch","parseQueryParam","matchQueryParams","matchUrlQueryParamValue","decodedKey","decodedVal","currentVal","allowPrimary","outletName","indexOf","substr","str","startsWith","NoMatch","ApplyRedirects","apply","expanded$","expandSegmentGroup","rxjs_operator_catch","_catch","urlTrees$","AbsoluteRedirect","match","expandSegment","allowRedirects","routes$","processedRoutes$","expandSegmentAgainstRoute","concattedProcessedRoutes$","rxjs_operator_concatAll","concatAll","first$","rxjs_operator_first","first","paths","getOutlet","expandWildCardWithParamsAgainstRouteUsingRedirect","expandRegularSegmentAgainstRouteUsingRedirect","matched","consumedSegments","lastChild","positionalParamSegments","matchSegmentAgainstRoute","rawSegmentGroup","cfg","noMatch","rawSlicedSegments","childConfig$","getChildConfig","routerConfig","childModule","runCanLoadGuard","shouldLoad","lineralizeSegments","createQueryParams","redirectToParams","actualParams","v","k","findOrReturn","redirectToUrlSegment","actualSegments","idx","_i","actualSegments_1","RouterState","_paramMap","_queryParamMap","ActivatedRouteSnapshot","routeConfig","urlSegment","lastPathIndex","RouterStateSnapshot","Navigation","isAbsolute","numberOfDoubleDots","Recognizer","rootSegmentGroup","split$1","processSegmentGroup","routeState","processSegment","config_1","processSegmentAgainstRoute","rawSegment","redirectTo","NoMatch$1","last$1","parameters","snapshot_1","freeze","getData","getSourceSegmentGroup","getPathIndexShift","getResolve","match$1","_b","startingPosition","findStartingPosition","oldSegmentGroup","newSegmentGroup","qp","replaceSegment","current","oldSegment","newSegment","computeNavigation","reduce","cmd","cmdIdx","outlets","outlets_1","concat","segmentPath","urlPart","partIndex","createPositionApplyingDoubleDots","group","index","g","ci","dd","getPath","command","updateSegmentGroup","startIndex","updateSegmentGroupChildren","m","prefixedWith","slicedCommands","commandIndex","pathIndex","outlets_2","getOutlets","children_2","currentCommandIndex","currentPathIndex","compare","createNewSegmentGroup","i","createNewSegmentChildren","isMatrixParams","pathMatch","posParams","checkOutletNameUniqueness","nodes","names","n","join","containsEmptyPathMatchesWithNamedOutlets","s_1","createChildrenForEmptyPaths","_sourceSegment","_segmentIndexShift","containsEmptyPathMatches","addEmptyPathsToChildrenIfNeeded","routes_3","primarySegment","routes_4","emptyPathMatch","createNode","prevState","createOrReuseChildren","setFutureSnapshotsOfActivatedRoutes","result","child","equalSegmentGroups","container","containee","equalPath","containsSegmentGroupHelper","containeePaths","containsSegmentGroup","mapChildrenIntoArray","segment","fn","childOutlet","serializeSegment","serializePaths","primary","children_1","replace","encode","matcher","defaultUrlMatcher","containsEmptyPathRedirectsWithNamedOutlets","containsEmptyPathRedirects","createChildrenForEmptySegments","primarySegmentGroup","isEmptyPathRedirect","findNode","findPath","createEmptyState","rootComponent","inheritedParamsDataResolve","inhertingStartingFrom","pathToRoot","parent","currentSnapshot","nextSnapshot","shallowEqual","shallowEqualArrays","k1","k2","waitForMap","obj","waitHead","waitTail","mapped","exports","factory","require","parts","part","substring","validateNode","fullPath","charAt","getFullPath","parentPath","currentRoute"],"mappings":"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"}