| 1 | {"version":3,"file":"core.umd.min.js","sources":["../../../../packages/core/src/metadata/lifecycle_hooks.ts","../../../../packages/core/src/core_private_export.ts","../../../../packages/core/src/view/services.ts","../../../../packages/core/src/application_module.ts","../../../../packages/core/src/view/refs.ts","../../../../packages/core/src/linker/view_container_ref.ts","../../../../packages/core/src/debug/debug_node.ts","../../../../packages/core/src/change_detection/change_detection_util.ts","../../../../packages/core/src/change_detection/differs/default_iterable_differ.ts","../../../../packages/core/src/change_detection/differs/default_keyvalue_differ.ts","../../../../packages/core/src/change_detection/differs/iterable_differs.ts","../../../../packages/core/src/change_detection/differs/keyvalue_differs.ts","../../../../packages/core/src/i18n/tokens.ts","../../../../packages/core/src/security.ts","../../../../packages/core/src/view/types.ts","../../../../packages/core/src/view/errors.ts","../../../../packages/core/src/view/util.ts","../../../../packages/core/src/render/api.ts","../../../../packages/core/src/linker/query_list.ts","../../../../packages/core/src/linker/system_js_ng_module_factory_loader.ts","../../../../packages/core/src/linker/compiler.ts","../../../../packages/core/src/profile/wtf_impl.ts","../../../../packages/core/src/linker/component_factory_resolver.ts","../../../../packages/core/src/linker/ng_module_factory.ts","../../../../packages/core/src/event_emitter.ts","../../../../packages/core/src/zone/ng_zone.ts","../../../../packages/core/src/testability/testability.ts","../../../../packages/core/src/application_ref.ts","../../../../packages/core/src/console.ts","../../../../packages/core/src/error_handler.ts","../../../../packages/core/src/di/reflective_key.ts","../../../../packages/core/src/reflection/reflection_capabilities.ts","../../../../packages/core/src/reflection/reflector.ts","../../../../packages/core/src/di/reflective_provider.ts","../../../../packages/core/src/di/reflective_injector.ts","../../../../packages/core/src/application_init.ts","../../../../packages/core/src/metadata/directives.ts","../../../../packages/core/src/metadata/view.ts","../../../../packages/core/src/metadata.ts","../../../../packages/core/src/version.ts","../../../../packages/core/src/di/injection_token.ts","../../../../packages/core/src/util.ts","../../../../packages/core/src/util/decorators.ts","../../../../packages/core/src/change_detection/constants.ts","../../../../packages/core/src/view/view.ts","../../../../packages/core/src/view/text.ts","../../../../packages/core/src/view/query.ts","../../../../packages/core/src/view/pure_expression.ts","../../../../packages/core/src/view/view_attach.ts","../../../../packages/core/src/view/provider.ts","../../../../packages/core/src/view/ng_content.ts","../../../../packages/core/src/view/element.ts","../../../../packages/core/src/platform_core_providers.ts","../../../../packages/core/src/linker/ng_module_factory_loader.ts","../../../../packages/core/src/di/reflective_errors.ts","../../../../packages/core/src/di/injector.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 {SimpleChange} from '../change_detection/change_detection_util';\nexport type LifecycleHooks = number;\nexport let LifecycleHooks: any = {};\nLifecycleHooks.OnInit = 0;\nLifecycleHooks.OnDestroy = 1;\nLifecycleHooks.DoCheck = 2;\nLifecycleHooks.OnChanges = 3;\nLifecycleHooks.AfterContentInit = 4;\nLifecycleHooks.AfterContentChecked = 5;\nLifecycleHooks.AfterViewInit = 6;\nLifecycleHooks.AfterViewChecked = 7;\nLifecycleHooks[LifecycleHooks.OnInit] = \"OnInit\";\nLifecycleHooks[LifecycleHooks.OnDestroy] = \"OnDestroy\";\nLifecycleHooks[LifecycleHooks.DoCheck] = \"DoCheck\";\nLifecycleHooks[LifecycleHooks.OnChanges] = \"OnChanges\";\nLifecycleHooks[LifecycleHooks.AfterContentInit] = \"AfterContentInit\";\nLifecycleHooks[LifecycleHooks.AfterContentChecked] = \"AfterContentChecked\";\nLifecycleHooks[LifecycleHooks.AfterViewInit] = \"AfterViewInit\";\nLifecycleHooks[LifecycleHooks.AfterViewChecked] = \"AfterViewChecked\";\n\n\n/**\n * A `changes` object whose keys are property names and\n * values are instances of {@link SimpleChange}. See {@link OnChanges}\n * @stable\n */\nexport interface SimpleChanges { [propName: string]: SimpleChange; }\n\nexport const /** @type {?} */ LIFECYCLE_HOOKS_VALUES = [\n LifecycleHooks.OnInit, LifecycleHooks.OnDestroy, LifecycleHooks.DoCheck, LifecycleHooks.OnChanges,\n LifecycleHooks.AfterContentInit, LifecycleHooks.AfterContentChecked, LifecycleHooks.AfterViewInit,\n LifecycleHooks.AfterViewChecked\n];\n\n/**\n * @whatItDoes Lifecycle hook that is called when any data-bound property of a directive changes.\n * @howToUse\n * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='OnChanges'}\n *\n * @description\n * `ngOnChanges` is called right after the data-bound properties have been checked and before view\n * and content children are checked if at least one of them has changed.\n * The `changes` parameter contains the changed properties.\n *\n * See {@linkDocs guide/lifecycle-hooks#onchanges \"Lifecycle Hooks Guide\"}.\n *\n * @stable\n */\nexport interface OnChanges { ngOnChanges(changes: SimpleChanges): void; }\n\n/**\n * @whatItDoes Lifecycle hook that is called after data-bound properties of a directive are\n * initialized.\n * @howToUse\n * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='OnInit'}\n *\n * @description\n * `ngOnInit` is called right after the directive's data-bound properties have been checked for the\n * first time, and before any of its children have been checked. It is invoked only once when the\n * directive is instantiated.\n *\n * See {@linkDocs guide/lifecycle-hooks \"Lifecycle Hooks Guide\"}.\n *\n * @stable\n */\nexport interface OnInit { ngOnInit(): void; }\n\n/**\n * @whatItDoes Lifecycle hook that is called when Angular dirty checks a directive.\n * @howToUse\n * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='DoCheck'}\n *\n * @description\n * `ngDoCheck` gets called to check the changes in the directives in addition to the default\n * algorithm. The default change detection algorithm looks for differences by comparing\n * bound-property values by reference across change detection runs.\n *\n * Note that a directive typically should not use both `DoCheck` and {@link OnChanges} to respond to\n * changes on the same input, as `ngOnChanges` will continue to be called when the default change\n * detector detects changes.\n *\n * See {@link KeyValueDiffers} and {@link IterableDiffers} for implementing custom dirty checking\n * for collections.\n *\n * See {@linkDocs guide/lifecycle-hooks#docheck \"Lifecycle Hooks Guide\"}.\n *\n * @stable\n */\nexport interface DoCheck { ngDoCheck(): void; }\n\n/**\n * @whatItDoes Lifecycle hook that is called when a directive, pipe or service is destroyed.\n * @howToUse\n * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='OnDestroy'}\n *\n * @description\n * `ngOnDestroy` callback is typically used for any custom cleanup that needs to occur when the\n * instance is destroyed.\n *\n * See {@linkDocs guide/lifecycle-hooks \"Lifecycle Hooks Guide\"}.\n *\n * @stable\n */\nexport interface OnDestroy { ngOnDestroy(): void; }\n\n/**\n *\n * @whatItDoes Lifecycle hook that is called after a directive's content has been fully\n * initialized.\n * @howToUse\n * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterContentInit'}\n *\n * @description\n * See {@linkDocs guide/lifecycle-hooks#aftercontent \"Lifecycle Hooks Guide\"}.\n *\n * @stable\n */\nexport interface AfterContentInit { ngAfterContentInit(): void; }\n\n/**\n * @whatItDoes Lifecycle hook that is called after every check of a directive's content.\n * @howToUse\n * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterContentChecked'}\n *\n * @description\n * See {@linkDocs guide/lifecycle-hooks#aftercontent \"Lifecycle Hooks Guide\"}.\n *\n * @stable\n */\nexport interface AfterContentChecked { ngAfterContentChecked(): void; }\n\n/**\n * @whatItDoes Lifecycle hook that is called after a component's view has been fully\n * initialized.\n * @howToUse\n * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterViewInit'}\n *\n * @description\n * See {@linkDocs guide/lifecycle-hooks#afterview \"Lifecycle Hooks Guide\"}.\n *\n * @stable\n */\nexport interface AfterViewInit { ngAfterViewInit(): void; }\n\n/**\n * @whatItDoes Lifecycle hook that is called after every check of a component's view.\n * @howToUse\n * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='AfterViewChecked'}\n *\n * @description\n * See {@linkDocs guide/lifecycle-hooks#afterview \"Lifecycle Hooks Guide\"}.\n *\n * @stable\n */\nexport interface AfterViewChecked { ngAfterViewChecked(): void; }\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\nexport {ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS} from './application_ref';\nexport {APP_ID_RANDOM_PROVIDER as ɵAPP_ID_RANDOM_PROVIDER} from './application_tokens';\nexport {ValueUnwrapper as ɵValueUnwrapper, devModeEqual as ɵdevModeEqual} from './change_detection/change_detection_util';\nexport {isListLikeIterable as ɵisListLikeIterable} from './change_detection/change_detection_util';\nexport {ChangeDetectorStatus as ɵChangeDetectorStatus, isDefaultChangeDetectionStrategy as ɵisDefaultChangeDetectionStrategy} from './change_detection/constants';\nexport {Console as ɵConsole} from './console';\nexport {ERROR_COMPONENT_TYPE as ɵERROR_COMPONENT_TYPE} from './errors';\nexport {ComponentFactory as ɵComponentFactory} from './linker/component_factory';\nexport {CodegenComponentFactoryResolver as ɵCodegenComponentFactoryResolver} from './linker/component_factory_resolver';\nexport {LIFECYCLE_HOOKS_VALUES as ɵLIFECYCLE_HOOKS_VALUES, LifecycleHooks as ɵLifecycleHooks} from './metadata/lifecycle_hooks';\nexport {ViewMetadata as ɵViewMetadata} from './metadata/view';\nexport {Reflector as ɵReflector, reflector as ɵreflector} from './reflection/reflection';\n// We need to import this name separately from the above wildcard, because this symbol is exposed.\nexport {ReflectionCapabilities as ɵReflectionCapabilities} from './reflection/reflection_capabilities';\nexport {ReflectorReader as ɵReflectorReader} from './reflection/reflector_reader';\nexport {GetterFn as ɵGetterFn, MethodFn as ɵMethodFn, SetterFn as ɵSetterFn} from './reflection/types';\nexport {DirectRenderer as ɵDirectRenderer, RenderDebugInfo as ɵRenderDebugInfo} from './render/api';\nexport {global as ɵglobal, looseIdentical as ɵlooseIdentical, stringify as ɵstringify} from './util';\nexport {makeDecorator as ɵmakeDecorator} from './util/decorators';\nexport {isObservable as ɵisObservable, isPromise as ɵisPromise} from './util/lang';\nexport {NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR} from './view/provider';\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 {isDevMode} from '../application_ref';\nimport {DebugElement, DebugNode, EventListener, getDebugNode, indexDebugNode, removeDebugNodeFromIndex} from '../debug/debug_node';\nimport {Injector} from '../di';\nimport {ErrorHandler} from '../error_handler';\nimport {NgModuleRef} from '../linker/ng_module_factory';\nimport {Renderer2, RendererFactory2, RendererStyleFlags2, RendererType2} from '../render/api';\nimport {Sanitizer} from '../security';\n\nimport {isViewDebugError, viewDestroyedError, viewWrappedDebugError} from './errors';\nimport {resolveDep} from './provider';\nimport {dirtyParentQueries, getQueryValue} from './query';\nimport {createInjector} from './refs';\nimport {ArgumentType, BindingFlags, CheckType, DebugContext, ElementData, NodeDef, NodeFlags, NodeLogger, RootData, Services, ViewData, ViewDefinition, ViewState, asElementData, asPureExpressionData} from './types';\nimport {NOOP, isComponentView, renderNode, viewParentEl} from './util';\nimport {checkAndUpdateNode, checkAndUpdateView, checkNoChangesNode, checkNoChangesView, createEmbeddedView, createRootView, destroyView} from './view';\n\n\nlet /** @type {?} */ initialized = false;\n/**\n * @return {?}\n */\nexport function initServicesIfNeeded() {\n if (initialized) {\n return;\n }\n initialized = true;\n const /** @type {?} */ services = isDevMode() ? createDebugServices() : createProdServices();\n Services.setCurrentNode = services.setCurrentNode;\n Services.createRootView = services.createRootView;\n Services.createEmbeddedView = services.createEmbeddedView;\n Services.checkAndUpdateView = services.checkAndUpdateView;\n Services.checkNoChangesView = services.checkNoChangesView;\n Services.destroyView = services.destroyView;\n Services.resolveDep = resolveDep;\n Services.createDebugContext = services.createDebugContext;\n Services.handleEvent = services.handleEvent;\n Services.updateDirectives = services.updateDirectives;\n Services.updateRenderer = services.updateRenderer;\n Services.dirtyParentQueries = dirtyParentQueries;\n}\n/**\n * @return {?}\n */\nfunction createProdServices() {\n return {\n setCurrentNode: () => {},\n createRootView: createProdRootView,\n createEmbeddedView: createEmbeddedView,\n checkAndUpdateView: checkAndUpdateView,\n checkNoChangesView: checkNoChangesView,\n destroyView: destroyView,\n createDebugContext: (view: ViewData, nodeIndex: number) => new DebugContext_(view, nodeIndex),\n handleEvent: (view: ViewData, nodeIndex: number, eventName: string, event: any) =>\n view.def.handleEvent(view, nodeIndex, eventName, event),\n updateDirectives: (view: ViewData, checkType: CheckType) => view.def.updateDirectives(\n checkType === CheckType.CheckAndUpdate ? prodCheckAndUpdateNode :\n prodCheckNoChangesNode,\n view),\n updateRenderer: (view: ViewData, checkType: CheckType) => view.def.updateRenderer(\n checkType === CheckType.CheckAndUpdate ? prodCheckAndUpdateNode :\n prodCheckNoChangesNode,\n view),\n };\n}\n/**\n * @return {?}\n */\nfunction createDebugServices() {\n return {\n setCurrentNode: debugSetCurrentNode,\n createRootView: debugCreateRootView,\n createEmbeddedView: debugCreateEmbeddedView,\n checkAndUpdateView: debugCheckAndUpdateView,\n checkNoChangesView: debugCheckNoChangesView,\n destroyView: debugDestroyView,\n createDebugContext: (view: ViewData, nodeIndex: number) => new DebugContext_(view, nodeIndex),\n handleEvent: debugHandleEvent,\n updateDirectives: debugUpdateDirectives,\n updateRenderer: debugUpdateRenderer\n };\n}\n/**\n * @param {?} elInjector\n * @param {?} projectableNodes\n * @param {?} rootSelectorOrNode\n * @param {?} def\n * @param {?} ngModule\n * @param {?=} context\n * @return {?}\n */\nfunction createProdRootView(\n elInjector: Injector, projectableNodes: any[][], rootSelectorOrNode: string | any,\n def: ViewDefinition, ngModule: NgModuleRef<any>, context?: any): ViewData {\n const /** @type {?} */ rendererFactory: RendererFactory2 = ngModule.injector.get(RendererFactory2);\n return createRootView(\n createRootData(elInjector, ngModule, rendererFactory, projectableNodes, rootSelectorOrNode),\n def, context);\n}\n/**\n * @param {?} elInjector\n * @param {?} projectableNodes\n * @param {?} rootSelectorOrNode\n * @param {?} def\n * @param {?} ngModule\n * @param {?=} context\n * @return {?}\n */\nfunction debugCreateRootView(\n elInjector: Injector, projectableNodes: any[][], rootSelectorOrNode: string | any,\n def: ViewDefinition, ngModule: NgModuleRef<any>, context?: any): ViewData {\n const /** @type {?} */ rendererFactory: RendererFactory2 = ngModule.injector.get(RendererFactory2);\n const /** @type {?} */ root = createRootData(\n elInjector, ngModule, new DebugRendererFactory2(rendererFactory), projectableNodes,\n rootSelectorOrNode);\n return callWithDebugContext(DebugAction.create, createRootView, null, [root, def, context]);\n}\n/**\n * @param {?} elInjector\n * @param {?} ngModule\n * @param {?} rendererFactory\n * @param {?} projectableNodes\n * @param {?} rootSelectorOrNode\n * @return {?}\n */\nfunction createRootData(\n elInjector: Injector, ngModule: NgModuleRef<any>, rendererFactory: RendererFactory2,\n projectableNodes: any[][], rootSelectorOrNode: any): RootData {\n const /** @type {?} */ sanitizer = ngModule.injector.get(Sanitizer);\n const /** @type {?} */ errorHandler = ngModule.injector.get(ErrorHandler);\n const /** @type {?} */ renderer = rendererFactory.createRenderer(null, null);\n return {\n ngModule,\n injector: elInjector, projectableNodes,\n selectorOrNode: rootSelectorOrNode, sanitizer, rendererFactory, renderer, errorHandler\n };\n}\n/**\n * @param {?} view\n * @param {?} nodeIndex\n * @param {?} argStyle\n * @param {?=} v0\n * @param {?=} v1\n * @param {?=} v2\n * @param {?=} v3\n * @param {?=} v4\n * @param {?=} v5\n * @param {?=} v6\n * @param {?=} v7\n * @param {?=} v8\n * @param {?=} v9\n * @return {?}\n */\nfunction prodCheckAndUpdateNode(\n view: ViewData, nodeIndex: number, argStyle: ArgumentType, v0?: any, v1?: any, v2?: any,\n v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): any {\n const /** @type {?} */ nodeDef = view.def.nodes[nodeIndex];\n checkAndUpdateNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n return (nodeDef.flags & NodeFlags.CatPureExpression) ?\n asPureExpressionData(view, nodeIndex).value :\n undefined;\n}\n/**\n * @param {?} view\n * @param {?} nodeIndex\n * @param {?} argStyle\n * @param {?=} v0\n * @param {?=} v1\n * @param {?=} v2\n * @param {?=} v3\n * @param {?=} v4\n * @param {?=} v5\n * @param {?=} v6\n * @param {?=} v7\n * @param {?=} v8\n * @param {?=} v9\n * @return {?}\n */\nfunction prodCheckNoChangesNode(\n view: ViewData, nodeIndex: number, argStyle: ArgumentType, v0?: any, v1?: any, v2?: any,\n v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): any {\n const /** @type {?} */ nodeDef = view.def.nodes[nodeIndex];\n checkNoChangesNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n return (nodeDef.flags & NodeFlags.CatPureExpression) ?\n asPureExpressionData(view, nodeIndex).value :\n undefined;\n}\n/**\n * @param {?} parent\n * @param {?} anchorDef\n * @param {?=} context\n * @return {?}\n */\nfunction debugCreateEmbeddedView(parent: ViewData, anchorDef: NodeDef, context?: any): ViewData {\n return callWithDebugContext(\n DebugAction.create, createEmbeddedView, null, [parent, anchorDef, context]);\n}\n/**\n * @param {?} view\n * @return {?}\n */\nfunction debugCheckAndUpdateView(view: ViewData) {\n return callWithDebugContext(DebugAction.detectChanges, checkAndUpdateView, null, [view]);\n}\n/**\n * @param {?} view\n * @return {?}\n */\nfunction debugCheckNoChangesView(view: ViewData) {\n return callWithDebugContext(DebugAction.checkNoChanges, checkNoChangesView, null, [view]);\n}\n/**\n * @param {?} view\n * @return {?}\n */\nfunction debugDestroyView(view: ViewData) {\n return callWithDebugContext(DebugAction.destroy, destroyView, null, [view]);\n}\ntype DebugAction = number;\nlet DebugAction: any = {};\nDebugAction.create = 0;\nDebugAction.detectChanges = 1;\nDebugAction.checkNoChanges = 2;\nDebugAction.destroy = 3;\nDebugAction.handleEvent = 4;\nDebugAction[DebugAction.create] = \"create\";\nDebugAction[DebugAction.detectChanges] = \"detectChanges\";\nDebugAction[DebugAction.checkNoChanges] = \"checkNoChanges\";\nDebugAction[DebugAction.destroy] = \"destroy\";\nDebugAction[DebugAction.handleEvent] = \"handleEvent\";\n\n\nlet /** @type {?} */ _currentAction: DebugAction;\nlet /** @type {?} */ _currentView: ViewData;\nlet /** @type {?} */ _currentNodeIndex: number|null;\n/**\n * @param {?} view\n * @param {?} nodeIndex\n * @return {?}\n */\nfunction debugSetCurrentNode(view: ViewData, nodeIndex: number | null) {\n _currentView = view;\n _currentNodeIndex = nodeIndex;\n}\n/**\n * @param {?} view\n * @param {?} nodeIndex\n * @param {?} eventName\n * @param {?} event\n * @return {?}\n */\nfunction debugHandleEvent(view: ViewData, nodeIndex: number, eventName: string, event: any) {\n debugSetCurrentNode(view, nodeIndex);\n return callWithDebugContext(\n DebugAction.handleEvent, view.def.handleEvent, null, [view, nodeIndex, eventName, event]);\n}\n/**\n * @param {?} view\n * @param {?} checkType\n * @return {?}\n */\nfunction debugUpdateDirectives(view: ViewData, checkType: CheckType) {\n if (view.state & ViewState.Destroyed) {\n throw viewDestroyedError(DebugAction[_currentAction]);\n }\n debugSetCurrentNode(view, nextDirectiveWithBinding(view, 0));\n return view.def.updateDirectives(debugCheckDirectivesFn, view);\n/**\n * @param {?} view\n * @param {?} nodeIndex\n * @param {?} argStyle\n * @param {...?} values\n * @return {?}\n */\nfunction debugCheckDirectivesFn(\n view: ViewData, nodeIndex: number, argStyle: ArgumentType, ...values: any[]) {\n const /** @type {?} */ nodeDef = view.def.nodes[nodeIndex];\n if (checkType === CheckType.CheckAndUpdate) {\n debugCheckAndUpdateNode(view, nodeDef, argStyle, values);\n } else {\n debugCheckNoChangesNode(view, nodeDef, argStyle, values);\n }\n if (nodeDef.flags & NodeFlags.TypeDirective) {\n debugSetCurrentNode(view, nextDirectiveWithBinding(view, nodeIndex));\n }\n return (nodeDef.flags & NodeFlags.CatPureExpression) ?\n asPureExpressionData(view, nodeDef.index).value :\n undefined;\n }\n}\n/**\n * @param {?} view\n * @param {?} checkType\n * @return {?}\n */\nfunction debugUpdateRenderer(view: ViewData, checkType: CheckType) {\n if (view.state & ViewState.Destroyed) {\n throw viewDestroyedError(DebugAction[_currentAction]);\n }\n debugSetCurrentNode(view, nextRenderNodeWithBinding(view, 0));\n return view.def.updateRenderer(debugCheckRenderNodeFn, view);\n/**\n * @param {?} view\n * @param {?} nodeIndex\n * @param {?} argStyle\n * @param {...?} values\n * @return {?}\n */\nfunction debugCheckRenderNodeFn(\n view: ViewData, nodeIndex: number, argStyle: ArgumentType, ...values: any[]) {\n const /** @type {?} */ nodeDef = view.def.nodes[nodeIndex];\n if (checkType === CheckType.CheckAndUpdate) {\n debugCheckAndUpdateNode(view, nodeDef, argStyle, values);\n } else {\n debugCheckNoChangesNode(view, nodeDef, argStyle, values);\n }\n if (nodeDef.flags & NodeFlags.CatRenderNode) {\n debugSetCurrentNode(view, nextRenderNodeWithBinding(view, nodeIndex));\n }\n return (nodeDef.flags & NodeFlags.CatPureExpression) ?\n asPureExpressionData(view, nodeDef.index).value :\n undefined;\n }\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @param {?} argStyle\n * @param {?} givenValues\n * @return {?}\n */\nfunction debugCheckAndUpdateNode(\n view: ViewData, nodeDef: NodeDef, argStyle: ArgumentType, givenValues: any[]): void {\n const /** @type {?} */ changed = ( /** @type {?} */((<any>checkAndUpdateNode)))(view, nodeDef, argStyle, ...givenValues);\n if (changed) {\n const /** @type {?} */ values = argStyle === ArgumentType.Dynamic ? givenValues[0] : givenValues;\n if (nodeDef.flags & NodeFlags.TypeDirective) {\n const /** @type {?} */ bindingValues: {[key: string]: string} = {};\n for (let /** @type {?} */ i = 0; i < nodeDef.bindings.length; i++) {\n const /** @type {?} */ binding = nodeDef.bindings[i];\n const /** @type {?} */ value = values[i];\n if (binding.flags & BindingFlags.TypeProperty) {\n bindingValues[normalizeDebugBindingName( /** @type {?} */((binding.nonMinifiedName)))] =\n normalizeDebugBindingValue(value);\n }\n }\n const /** @type {?} */ elDef = /** @type {?} */(( nodeDef.parent));\n const /** @type {?} */ el = asElementData(view, elDef.index).renderElement;\n if (! /** @type {?} */((elDef.element)).name) {\n // a comment.\n view.renderer.setValue(el, `bindings=${JSON.stringify(bindingValues, null, 2)}`);\n } else {\n // a regular element.\n for (let /** @type {?} */ attr in bindingValues) {\n const /** @type {?} */ value = bindingValues[attr];\n if (value != null) {\n view.renderer.setAttribute(el, attr, value);\n } else {\n view.renderer.removeAttribute(el, attr);\n }\n }\n }\n }\n }\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @param {?} argStyle\n * @param {?} values\n * @return {?}\n */\nfunction debugCheckNoChangesNode(\n view: ViewData, nodeDef: NodeDef, argStyle: ArgumentType, values: any[]): void {\n ( /** @type {?} */((<any>checkNoChangesNode)))(view, nodeDef, argStyle, ...values);\n}\n/**\n * @param {?} name\n * @return {?}\n */\nfunction normalizeDebugBindingName(name: string) {\n // Attribute names with `$` (eg `x-y$`) are valid per spec, but unsupported by some browsers\n name = camelCaseToDashCase(name.replace(/[$@]/g, '_'));\n return `ng-reflect-${name}`;\n}\n\nconst /** @type {?} */ CAMEL_CASE_REGEXP = /([A-Z])/g;\n/**\n * @param {?} input\n * @return {?}\n */\nfunction camelCaseToDashCase(input: string): string {\n return input.replace(CAMEL_CASE_REGEXP, (...m: any[]) => '-' + m[1].toLowerCase());\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction normalizeDebugBindingValue(value: any): string {\n try {\n // Limit the size of the value as otherwise the DOM just gets polluted.\n return value != null ? value.toString().slice(0, 30) : value;\n } catch ( /** @type {?} */e) {\n return '[ERROR] Exception while trying to serialize the value';\n }\n}\n/**\n * @param {?} view\n * @param {?} nodeIndex\n * @return {?}\n */\nfunction nextDirectiveWithBinding(view: ViewData, nodeIndex: number): number|null {\n for (let /** @type {?} */ i = nodeIndex; i < view.def.nodes.length; i++) {\n const /** @type {?} */ nodeDef = view.def.nodes[i];\n if (nodeDef.flags & NodeFlags.TypeDirective && nodeDef.bindings && nodeDef.bindings.length) {\n return i;\n }\n }\n return null;\n}\n/**\n * @param {?} view\n * @param {?} nodeIndex\n * @return {?}\n */\nfunction nextRenderNodeWithBinding(view: ViewData, nodeIndex: number): number|null {\n for (let /** @type {?} */ i = nodeIndex; i < view.def.nodes.length; i++) {\n const /** @type {?} */ nodeDef = view.def.nodes[i];\n if ((nodeDef.flags & NodeFlags.CatRenderNode) && nodeDef.bindings && nodeDef.bindings.length) {\n return i;\n }\n }\n return null;\n}\nclass DebugContext_ implements DebugContext {\nprivate nodeDef: NodeDef;\nprivate elView: ViewData;\nprivate elDef: NodeDef;\n/**\n * @param {?} view\n * @param {?} nodeIndex\n */\nconstructor(public view: ViewData,\npublic nodeIndex: number|null) {\n if (nodeIndex == null) {\n this.nodeIndex = nodeIndex = 0;\n }\n this.nodeDef = view.def.nodes[nodeIndex];\n let elDef = this.nodeDef;\n let elView = view;\n while (elDef && (elDef.flags & NodeFlags.TypeElement) === 0) {\n elDef = elDef.parent !;\n }\n if (!elDef) {\n while (!elDef && elView) {\n elDef = viewParentEl(elView) !;\n elView = elView.parent !;\n }\n }\n this.elDef = elDef;\n this.elView = elView;\n }\n/**\n * @return {?}\n */\nprivate get elOrCompView() {\n // Has to be done lazily as we use the DebugContext also during creation of elements...\n return asElementData(this.elView, this.elDef.index).componentView || this.view;\n }\n/**\n * @return {?}\n */\nget injector(): Injector { return createInjector(this.elView, this.elDef); }\n/**\n * @return {?}\n */\nget component(): any { return this.elOrCompView.component; }\n/**\n * @return {?}\n */\nget context(): any { return this.elOrCompView.context; }\n/**\n * @return {?}\n */\nget providerTokens(): any[] {\n const /** @type {?} */ tokens: any[] = [];\n if (this.elDef) {\n for (let /** @type {?} */ i = this.elDef.index + 1; i <= this.elDef.index + this.elDef.childCount; i++) {\n const /** @type {?} */ childDef = this.elView.def.nodes[i];\n if (childDef.flags & NodeFlags.CatProvider) {\n tokens.push( /** @type {?} */((childDef.provider)).token);\n }\n i += childDef.childCount;\n }\n }\n return tokens;\n }\n/**\n * @return {?}\n */\nget references(): {[key: string]: any} {\n const /** @type {?} */ references: {[key: string]: any} = {};\n if (this.elDef) {\n collectReferences(this.elView, this.elDef, references);\n\n for (let /** @type {?} */ i = this.elDef.index + 1; i <= this.elDef.index + this.elDef.childCount; i++) {\n const /** @type {?} */ childDef = this.elView.def.nodes[i];\n if (childDef.flags & NodeFlags.CatProvider) {\n collectReferences(this.elView, childDef, references);\n }\n i += childDef.childCount;\n }\n }\n return references;\n }\n/**\n * @return {?}\n */\nget componentRenderElement() {\n const /** @type {?} */ elData = findHostElement(this.elOrCompView);\n return elData ? elData.renderElement : undefined;\n }\n/**\n * @return {?}\n */\nget renderNode(): any {\n return this.nodeDef.flags & NodeFlags.TypeText ? renderNode(this.view, this.nodeDef) :\n renderNode(this.elView, this.elDef);\n }\n/**\n * @param {?} console\n * @param {...?} values\n * @return {?}\n */\nlogError(console: Console, ...values: any[]) {\n let /** @type {?} */ logViewDef: ViewDefinition;\n let /** @type {?} */ logNodeIndex: number;\n if (this.nodeDef.flags & NodeFlags.TypeText) {\n logViewDef = this.view.def;\n logNodeIndex = this.nodeDef.index;\n } else {\n logViewDef = this.elView.def;\n logNodeIndex = this.elDef.index;\n }\n // Note: we only generate a log function for text and element nodes\n // to make the generated code as small as possible.\n const /** @type {?} */ renderNodeIndex = getRenderNodeIndex(logViewDef, logNodeIndex);\n let /** @type {?} */ currRenderNodeIndex = -1;\n let /** @type {?} */ nodeLogger: NodeLogger = () => {\n currRenderNodeIndex++;\n if (currRenderNodeIndex === renderNodeIndex) {\n return console.error.bind(console, ...values);\n } else {\n return NOOP;\n }\n }; /** @type {?} */((\n logViewDef.factory))(nodeLogger);\n if (currRenderNodeIndex < renderNodeIndex) {\n console.error('Illegal state: the ViewDefinitionFactory did not call the logger!');\n ( /** @type {?} */((<any>console.error)))(...values);\n }\n }\n}\n\nfunction DebugContext__tsickle_Closure_declarations() {\n/** @type {?} */\nDebugContext_.prototype.nodeDef;\n/** @type {?} */\nDebugContext_.prototype.elView;\n/** @type {?} */\nDebugContext_.prototype.elDef;\n/** @type {?} */\nDebugContext_.prototype.view;\n/** @type {?} */\nDebugContext_.prototype.nodeIndex;\n}\n\n/**\n * @param {?} viewDef\n * @param {?} nodeIndex\n * @return {?}\n */\nfunction getRenderNodeIndex(viewDef: ViewDefinition, nodeIndex: number): number {\n let /** @type {?} */ renderNodeIndex = -1;\n for (let /** @type {?} */ i = 0; i <= nodeIndex; i++) {\n const /** @type {?} */ nodeDef = viewDef.nodes[i];\n if (nodeDef.flags & NodeFlags.CatRenderNode) {\n renderNodeIndex++;\n }\n }\n return renderNodeIndex;\n}\n/**\n * @param {?} view\n * @return {?}\n */\nfunction findHostElement(view: ViewData): ElementData|null {\n while (view && !isComponentView(view)) {\n view = /** @type {?} */(( view.parent));\n }\n if (view.parent) {\n return asElementData(view.parent, /** @type {?} */(( viewParentEl(view))).index);\n }\n return null;\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @param {?} references\n * @return {?}\n */\nfunction collectReferences(view: ViewData, nodeDef: NodeDef, references: {[key: string]: any}) {\n for (let /** @type {?} */ refName in nodeDef.references) {\n references[refName] = getQueryValue(view, nodeDef, nodeDef.references[refName]);\n }\n}\n/**\n * @param {?} action\n * @param {?} fn\n * @param {?} self\n * @param {?} args\n * @return {?}\n */\nfunction callWithDebugContext(action: DebugAction, fn: any, self: any, args: any[]) {\n const /** @type {?} */ oldAction = _currentAction;\n const /** @type {?} */ oldView = _currentView;\n const /** @type {?} */ oldNodeIndex = _currentNodeIndex;\n try {\n _currentAction = action;\n const /** @type {?} */ result = fn.apply(self, args);\n _currentView = oldView;\n _currentNodeIndex = oldNodeIndex;\n _currentAction = oldAction;\n return result;\n } catch ( /** @type {?} */e) {\n if (isViewDebugError(e) || !_currentView) {\n throw e;\n }\n throw viewWrappedDebugError(e, /** @type {?} */(( getCurrentDebugContext())));\n }\n}\n/**\n * @return {?}\n */\nexport function getCurrentDebugContext(): DebugContext|null {\n return _currentView ? new DebugContext_(_currentView, _currentNodeIndex) : null;\n}\nclass DebugRendererFactory2 implements RendererFactory2 {\n/**\n * @param {?} delegate\n */\nconstructor(private delegate: RendererFactory2) {}\n/**\n * @param {?} element\n * @param {?} renderData\n * @return {?}\n */\ncreateRenderer(element: any, renderData: RendererType2|null): Renderer2 {\n return new DebugRenderer2(this.delegate.createRenderer(element, renderData));\n }\n}\n\nfunction DebugRendererFactory2_tsickle_Closure_declarations() {\n/** @type {?} */\nDebugRendererFactory2.prototype.delegate;\n}\n\nclass DebugRenderer2 implements Renderer2 {\n/**\n * @param {?} delegate\n */\nconstructor(private delegate: Renderer2) {}\n/**\n * @return {?}\n */\nget data() { return this.delegate.data; }\n/**\n * @param {?} node\n * @return {?}\n */\ndestroyNode(node: any) {\n removeDebugNodeFromIndex( /** @type {?} */((getDebugNode(node))));\n if (this.delegate.destroyNode) {\n this.delegate.destroyNode(node);\n }\n }\n/**\n * @return {?}\n */\ndestroy() { this.delegate.destroy(); }\n/**\n * @param {?} name\n * @param {?=} namespace\n * @return {?}\n */\ncreateElement(name: string, namespace?: string): any {\n const /** @type {?} */ el = this.delegate.createElement(name, namespace);\n const /** @type {?} */ debugCtx = getCurrentDebugContext();\n if (debugCtx) {\n const /** @type {?} */ debugEl = new DebugElement(el, null, debugCtx);\n debugEl.name = name;\n indexDebugNode(debugEl);\n }\n return el;\n }\n/**\n * @param {?} value\n * @return {?}\n */\ncreateComment(value: string): any {\n const /** @type {?} */ comment = this.delegate.createComment(value);\n const /** @type {?} */ debugCtx = getCurrentDebugContext();\n if (debugCtx) {\n indexDebugNode(new DebugNode(comment, null, debugCtx));\n }\n return comment;\n }\n/**\n * @param {?} value\n * @return {?}\n */\ncreateText(value: string): any {\n const /** @type {?} */ text = this.delegate.createText(value);\n const /** @type {?} */ debugCtx = getCurrentDebugContext();\n if (debugCtx) {\n indexDebugNode(new DebugNode(text, null, debugCtx));\n }\n return text;\n }\n/**\n * @param {?} parent\n * @param {?} newChild\n * @return {?}\n */\nappendChild(parent: any, newChild: any): void {\n const /** @type {?} */ debugEl = getDebugNode(parent);\n const /** @type {?} */ debugChildEl = getDebugNode(newChild);\n if (debugEl && debugChildEl && debugEl instanceof DebugElement) {\n debugEl.addChild(debugChildEl);\n }\n this.delegate.appendChild(parent, newChild);\n }\n/**\n * @param {?} parent\n * @param {?} newChild\n * @param {?} refChild\n * @return {?}\n */\ninsertBefore(parent: any, newChild: any, refChild: any): void {\n const /** @type {?} */ debugEl = getDebugNode(parent);\n const /** @type {?} */ debugChildEl = getDebugNode(newChild);\n const /** @type {?} */ debugRefEl = /** @type {?} */(( getDebugNode(refChild)));\n if (debugEl && debugChildEl && debugEl instanceof DebugElement) {\n debugEl.insertBefore(debugRefEl, debugChildEl);\n }\n\n this.delegate.insertBefore(parent, newChild, refChild);\n }\n/**\n * @param {?} parent\n * @param {?} oldChild\n * @return {?}\n */\nremoveChild(parent: any, oldChild: any): void {\n const /** @type {?} */ debugEl = getDebugNode(parent);\n const /** @type {?} */ debugChildEl = getDebugNode(oldChild);\n if (debugEl && debugChildEl && debugEl instanceof DebugElement) {\n debugEl.removeChild(debugChildEl);\n }\n this.delegate.removeChild(parent, oldChild);\n }\n/**\n * @param {?} selectorOrNode\n * @return {?}\n */\nselectRootElement(selectorOrNode: string|any): any {\n const /** @type {?} */ el = this.delegate.selectRootElement(selectorOrNode);\n const /** @type {?} */ debugCtx = getCurrentDebugContext();\n if (debugCtx) {\n indexDebugNode(new DebugElement(el, null, debugCtx));\n }\n return el;\n }\n/**\n * @param {?} el\n * @param {?} name\n * @param {?} value\n * @param {?=} namespace\n * @return {?}\n */\nsetAttribute(el: any, name: string, value: string, namespace?: string): void {\n const /** @type {?} */ debugEl = getDebugNode(el);\n if (debugEl && debugEl instanceof DebugElement) {\n const /** @type {?} */ fullName = namespace ? namespace + ':' + name : name;\n debugEl.attributes[fullName] = value;\n }\n this.delegate.setAttribute(el, name, value, namespace);\n }\n/**\n * @param {?} el\n * @param {?} name\n * @param {?=} namespace\n * @return {?}\n */\nremoveAttribute(el: any, name: string, namespace?: string): void {\n const /** @type {?} */ debugEl = getDebugNode(el);\n if (debugEl && debugEl instanceof DebugElement) {\n const /** @type {?} */ fullName = namespace ? namespace + ':' + name : name;\n debugEl.attributes[fullName] = null;\n }\n this.delegate.removeAttribute(el, name, namespace);\n }\n/**\n * @param {?} el\n * @param {?} name\n * @return {?}\n */\naddClass(el: any, name: string): void {\n const /** @type {?} */ debugEl = getDebugNode(el);\n if (debugEl && debugEl instanceof DebugElement) {\n debugEl.classes[name] = true;\n }\n this.delegate.addClass(el, name);\n }\n/**\n * @param {?} el\n * @param {?} name\n * @return {?}\n */\nremoveClass(el: any, name: string): void {\n const /** @type {?} */ debugEl = getDebugNode(el);\n if (debugEl && debugEl instanceof DebugElement) {\n debugEl.classes[name] = false;\n }\n this.delegate.removeClass(el, name);\n }\n/**\n * @param {?} el\n * @param {?} style\n * @param {?} value\n * @param {?} flags\n * @return {?}\n */\nsetStyle(el: any, style: string, value: any, flags: RendererStyleFlags2): void {\n const /** @type {?} */ debugEl = getDebugNode(el);\n if (debugEl && debugEl instanceof DebugElement) {\n debugEl.styles[style] = value;\n }\n this.delegate.setStyle(el, style, value, flags);\n }\n/**\n * @param {?} el\n * @param {?} style\n * @param {?} flags\n * @return {?}\n */\nremoveStyle(el: any, style: string, flags: RendererStyleFlags2): void {\n const /** @type {?} */ debugEl = getDebugNode(el);\n if (debugEl && debugEl instanceof DebugElement) {\n debugEl.styles[style] = null;\n }\n this.delegate.removeStyle(el, style, flags);\n }\n/**\n * @param {?} el\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\nsetProperty(el: any, name: string, value: any): void {\n const /** @type {?} */ debugEl = getDebugNode(el);\n if (debugEl && debugEl instanceof DebugElement) {\n debugEl.properties[name] = value;\n }\n this.delegate.setProperty(el, name, value);\n }\n/**\n * @param {?} target\n * @param {?} eventName\n * @param {?} callback\n * @return {?}\n */\nlisten(\n target: 'document'|'windows'|'body'|any, eventName: string,\n callback: (event: any) => boolean): () => void {\n if (typeof target !== 'string') {\n const /** @type {?} */ debugEl = getDebugNode(target);\n if (debugEl) {\n debugEl.listeners.push(new EventListener(eventName, callback));\n }\n }\n\n return this.delegate.listen(target, eventName, callback);\n }\n/**\n * @param {?} node\n * @return {?}\n */\nparentNode(node: any): any { return this.delegate.parentNode(node); }\n/**\n * @param {?} node\n * @return {?}\n */\nnextSibling(node: any): any { return this.delegate.nextSibling(node); }\n/**\n * @param {?} node\n * @param {?} value\n * @return {?}\n */\nsetValue(node: any, value: string): void { return this.delegate.setValue(node, value); }\n}\n\nfunction DebugRenderer2_tsickle_Closure_declarations() {\n/** @type {?} */\nDebugRenderer2.prototype.delegate;\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 {APP_INITIALIZER, ApplicationInitStatus} from './application_init';\nimport {ApplicationRef, ApplicationRef_} from './application_ref';\nimport {APP_ID_RANDOM_PROVIDER} from './application_tokens';\nimport {IterableDiffers, KeyValueDiffers, defaultIterableDiffers, defaultKeyValueDiffers} from './change_detection/change_detection';\nimport {Inject, Optional, SkipSelf} from './di/metadata';\nimport {LOCALE_ID} from './i18n/tokens';\nimport {Compiler} from './linker/compiler';\nimport {NgModule} from './metadata';\nimport {initServicesIfNeeded} from './view/index';\n/**\n * @return {?}\n */\nexport function _iterableDiffersFactory() {\n return defaultIterableDiffers;\n}\n/**\n * @return {?}\n */\nexport function _keyValueDiffersFactory() {\n return defaultKeyValueDiffers;\n}\n/**\n * @param {?=} locale\n * @return {?}\n */\nexport function _localeFactory(locale?: string): string {\n return locale || 'en-US';\n}\n/**\n * @return {?}\n */\nexport function _initViewEngine() {\n initServicesIfNeeded();\n}\n/**\n * This module includes the providers of \\@angular/core that are needed\n * to bootstrap components via `ApplicationRef`.\n * \n * \\@experimental\n */\nexport class ApplicationModule {\n/**\n * @param {?} appRef\n */\nconstructor(appRef: ApplicationRef) {}\nstatic decorators: DecoratorInvocation[] = [\n{ type: NgModule, args: [{\n providers: [\n ApplicationRef_,\n {provide: ApplicationRef, useExisting: ApplicationRef_},\n ApplicationInitStatus,\n Compiler,\n APP_ID_RANDOM_PROVIDER,\n {provide: IterableDiffers, useFactory: _iterableDiffersFactory},\n {provide: KeyValueDiffers, useFactory: _keyValueDiffersFactory},\n {\n provide: LOCALE_ID,\n useFactory: _localeFactory,\n deps: [[new Inject(LOCALE_ID), new Optional(), new SkipSelf()]]\n },\n {provide: APP_INITIALIZER, useValue: _initViewEngine, multi: true},\n ]\n}, ] },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: ApplicationRef, },\n];\n}\n\nfunction ApplicationModule_tsickle_Closure_declarations() {\n/** @type {?} */\nApplicationModule.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nApplicationModule.ctorParameters;\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 {ApplicationRef} from '../application_ref';\nimport {ChangeDetectorRef} from '../change_detection/change_detection';\nimport {Injector} from '../di';\nimport {ComponentFactory, ComponentRef} from '../linker/component_factory';\nimport {ComponentFactoryBoundToModule} from '../linker/component_factory_resolver';\nimport {ElementRef} from '../linker/element_ref';\nimport {NgModuleRef} from '../linker/ng_module_factory';\nimport {TemplateRef} from '../linker/template_ref';\nimport {ViewContainerRef} from '../linker/view_container_ref';\nimport {EmbeddedViewRef, InternalViewRef, ViewRef} from '../linker/view_ref';\nimport {Renderer as RendererV1, Renderer2} from '../render/api';\nimport {Type} from '../type';\nimport {VERSION} from '../version';\n\nimport {DepFlags, ElementData, NodeDef, NodeFlags, Services, TemplateData, ViewContainerData, ViewData, ViewDefinitionFactory, ViewState, asElementData, asProviderData, asTextData} from './types';\nimport {markParentViewsForCheck, resolveViewDefinition, rootRenderNodes, splitNamespace, tokenKey, viewParentEl} from './util';\nimport {attachEmbeddedView, detachEmbeddedView, moveEmbeddedView, renderDetachView} from './view_attach';\n\nconst /** @type {?} */ EMPTY_CONTEXT = new Object();\n/**\n * @param {?} selector\n * @param {?} componentType\n * @param {?} viewDefFactory\n * @param {?} inputs\n * @param {?} outputs\n * @param {?} ngContentSelectors\n * @return {?}\n */\nexport function createComponentFactory(\n selector: string, componentType: Type<any>, viewDefFactory: ViewDefinitionFactory,\n inputs: {[propName: string]: string} | null, outputs: {[propName: string]: string},\n ngContentSelectors: string[]): ComponentFactory<any> {\n return new ComponentFactory_(\n selector, componentType, viewDefFactory, inputs, outputs, ngContentSelectors);\n}\n/**\n * @param {?} componentFactory\n * @return {?}\n */\nexport function getComponentViewDefinitionFactory(componentFactory: ComponentFactory<any>):\n ViewDefinitionFactory {\n return ( /** @type {?} */((componentFactory as ComponentFactory_))).viewDefFactory;\n}\nclass ComponentFactory_ extends ComponentFactory<any> {\n/**\n * \\@internal\n */\nviewDefFactory: ViewDefinitionFactory;\n/**\n * @param {?} selector\n * @param {?} componentType\n * @param {?} viewDefFactory\n * @param {?} _inputs\n * @param {?} _outputs\n * @param {?} ngContentSelectors\n */\nconstructor(\npublic selector: string,\npublic componentType: Type<any>,\n viewDefFactory: ViewDefinitionFactory,\nprivate _inputs: {[propName: string]: string}|null,\nprivate _outputs: {[propName: string]: string},\npublic ngContentSelectors: string[]) {\n // Attention: this ctor is called as top level function.\n // Putting any logic in here will destroy closure tree shaking!\n super();\n this.viewDefFactory = viewDefFactory;\n }\n/**\n * @return {?}\n */\nget inputs() {\n const /** @type {?} */ inputsArr: {propName: string, templateName: string}[] = [];\n const /** @type {?} */ inputs = /** @type {?} */(( this._inputs));\n for (let /** @type {?} */ propName in inputs) {\n const /** @type {?} */ templateName = inputs[propName];\n inputsArr.push({propName, templateName});\n }\n return inputsArr;\n }\n/**\n * @return {?}\n */\nget outputs() {\n const /** @type {?} */ outputsArr: {propName: string, templateName: string}[] = [];\n for (let /** @type {?} */ propName in this._outputs) {\n const /** @type {?} */ templateName = this._outputs[propName];\n outputsArr.push({propName, templateName});\n }\n return outputsArr;\n }\n/**\n * Creates a new component.\n * @param {?} injector\n * @param {?=} projectableNodes\n * @param {?=} rootSelectorOrNode\n * @param {?=} ngModule\n * @return {?}\n */\ncreate(\n injector: Injector, projectableNodes?: any[][], rootSelectorOrNode?: string|any,\n ngModule?: NgModuleRef<any>): ComponentRef<any> {\n if (!ngModule) {\n throw new Error('ngModule should be provided');\n }\n const /** @type {?} */ viewDef = resolveViewDefinition(this.viewDefFactory);\n const /** @type {?} */ componentNodeIndex = /** @type {?} */(( /** @type {?} */(( viewDef.nodes[0].element)).componentProvider)).index;\n const /** @type {?} */ view = Services.createRootView(\n injector, projectableNodes || [], rootSelectorOrNode, viewDef, ngModule, EMPTY_CONTEXT);\n const /** @type {?} */ component = asProviderData(view, componentNodeIndex).instance;\n if (rootSelectorOrNode) {\n view.renderer.setAttribute(asElementData(view, 0).renderElement, 'ng-version', VERSION.full);\n }\n\n return new ComponentRef_(view, new ViewRef_(view), component);\n }\n}\n\nfunction ComponentFactory__tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\nComponentFactory_.prototype.viewDefFactory;\n/** @type {?} */\nComponentFactory_.prototype.selector;\n/** @type {?} */\nComponentFactory_.prototype.componentType;\n/** @type {?} */\nComponentFactory_.prototype._inputs;\n/** @type {?} */\nComponentFactory_.prototype._outputs;\n/** @type {?} */\nComponentFactory_.prototype.ngContentSelectors;\n}\n\nclass ComponentRef_ extends ComponentRef<any> {\nprivate _elDef: NodeDef;\n/**\n * @param {?} _view\n * @param {?} _viewRef\n * @param {?} _component\n */\nconstructor(private _view: ViewData,\nprivate _viewRef: ViewRef,\nprivate _component: any) {\n super();\n this._elDef = this._view.def.nodes[0];\n }\n/**\n * @return {?}\n */\nget location(): ElementRef {\n return new ElementRef(asElementData(this._view, this._elDef.index).renderElement);\n }\n/**\n * @return {?}\n */\nget injector(): Injector { return new Injector_(this._view, this._elDef); }\n/**\n * @return {?}\n */\nget instance(): any { return this._component; };\n/**\n * @return {?}\n */\nget hostView(): ViewRef { return this._viewRef; };\n/**\n * @return {?}\n */\nget changeDetectorRef(): ChangeDetectorRef { return this._viewRef; };\n/**\n * @return {?}\n */\nget componentType(): Type<any> { return /** @type {?} */(( <any>this._component.constructor)); }\n/**\n * @return {?}\n */\ndestroy(): void { this._viewRef.destroy(); }\n/**\n * @param {?} callback\n * @return {?}\n */\nonDestroy(callback: Function): void { this._viewRef.onDestroy(callback); }\n}\n\nfunction ComponentRef__tsickle_Closure_declarations() {\n/** @type {?} */\nComponentRef_.prototype._elDef;\n/** @type {?} */\nComponentRef_.prototype._view;\n/** @type {?} */\nComponentRef_.prototype._viewRef;\n/** @type {?} */\nComponentRef_.prototype._component;\n}\n\n/**\n * @param {?} view\n * @param {?} elDef\n * @param {?} elData\n * @return {?}\n */\nexport function createViewContainerData(\n view: ViewData, elDef: NodeDef, elData: ElementData): ViewContainerData {\n return new ViewContainerRef_(view, elDef, elData);\n}\nclass ViewContainerRef_ implements ViewContainerData {\n/**\n * \\@internal\n */\n_embeddedViews: ViewData[] = [];\n/**\n * @param {?} _view\n * @param {?} _elDef\n * @param {?} _data\n */\nconstructor(private _view: ViewData,\nprivate _elDef: NodeDef,\nprivate _data: ElementData) {}\n/**\n * @return {?}\n */\nget element(): ElementRef { return new ElementRef(this._data.renderElement); }\n/**\n * @return {?}\n */\nget injector(): Injector { return new Injector_(this._view, this._elDef); }\n/**\n * @return {?}\n */\nget parentInjector(): Injector {\n let /** @type {?} */ view = this._view;\n let /** @type {?} */ elDef = this._elDef.parent;\n while (!elDef && view) {\n elDef = viewParentEl(view);\n view = /** @type {?} */(( view.parent));\n }\n\n return view ? new Injector_(view, elDef) : new Injector_(this._view, null);\n }\n/**\n * @return {?}\n */\nclear(): void {\n const /** @type {?} */ len = this._embeddedViews.length;\n for (let /** @type {?} */ i = len - 1; i >= 0; i--) {\n const /** @type {?} */ view = /** @type {?} */(( detachEmbeddedView(this._data, i)));\n Services.destroyView(view);\n }\n }\n/**\n * @param {?} index\n * @return {?}\n */\nget(index: number): ViewRef|null {\n const /** @type {?} */ view = this._embeddedViews[index];\n if (view) {\n const /** @type {?} */ ref = new ViewRef_(view);\n ref.attachToViewContainerRef(this);\n return ref;\n }\n return null;\n }\n/**\n * @return {?}\n */\nget length(): number { return this._embeddedViews.length; };\n/**\n * @template C\n * @param {?} templateRef\n * @param {?=} context\n * @param {?=} index\n * @return {?}\n */\ncreateEmbeddedView<C>(templateRef: TemplateRef<C>, context?: C, index?: number):\n EmbeddedViewRef<C> {\n const /** @type {?} */ viewRef = templateRef.createEmbeddedView(context || /** @type {?} */(( <any>{})));\n this.insert(viewRef, index);\n return viewRef;\n }\n/**\n * @template C\n * @param {?} componentFactory\n * @param {?=} index\n * @param {?=} injector\n * @param {?=} projectableNodes\n * @param {?=} ngModuleRef\n * @return {?}\n */\ncreateComponent<C>(\n componentFactory: ComponentFactory<C>, index?: number, injector?: Injector,\n projectableNodes?: any[][], ngModuleRef?: NgModuleRef<any>): ComponentRef<C> {\n const /** @type {?} */ contextInjector = injector || this.parentInjector;\n if (!ngModuleRef && !(componentFactory instanceof ComponentFactoryBoundToModule)) {\n ngModuleRef = contextInjector.get(NgModuleRef);\n }\n const /** @type {?} */ componentRef =\n componentFactory.create(contextInjector, projectableNodes, undefined, ngModuleRef);\n this.insert(componentRef.hostView, index);\n return componentRef;\n }\n/**\n * @param {?} viewRef\n * @param {?=} index\n * @return {?}\n */\ninsert(viewRef: ViewRef, index?: number): ViewRef {\n const /** @type {?} */ viewRef_ = /** @type {?} */(( <ViewRef_>viewRef));\n const /** @type {?} */ viewData = viewRef_._view;\n attachEmbeddedView(this._view, this._data, index, viewData);\n viewRef_.attachToViewContainerRef(this);\n return viewRef;\n }\n/**\n * @param {?} viewRef\n * @param {?} currentIndex\n * @return {?}\n */\nmove(viewRef: ViewRef_, currentIndex: number): ViewRef {\n const /** @type {?} */ previousIndex = this._embeddedViews.indexOf(viewRef._view);\n moveEmbeddedView(this._data, previousIndex, currentIndex);\n return viewRef;\n }\n/**\n * @param {?} viewRef\n * @return {?}\n */\nindexOf(viewRef: ViewRef): number {\n return this._embeddedViews.indexOf(( /** @type {?} */((<ViewRef_>viewRef)))._view);\n }\n/**\n * @param {?=} index\n * @return {?}\n */\nremove(index?: number): void {\n const /** @type {?} */ viewData = detachEmbeddedView(this._data, index);\n if (viewData) {\n Services.destroyView(viewData);\n }\n }\n/**\n * @param {?=} index\n * @return {?}\n */\ndetach(index?: number): ViewRef|null {\n const /** @type {?} */ view = detachEmbeddedView(this._data, index);\n return view ? new ViewRef_(view) : null;\n }\n}\n\nfunction ViewContainerRef__tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\nViewContainerRef_.prototype._embeddedViews;\n/** @type {?} */\nViewContainerRef_.prototype._view;\n/** @type {?} */\nViewContainerRef_.prototype._elDef;\n/** @type {?} */\nViewContainerRef_.prototype._data;\n}\n\n/**\n * @param {?} view\n * @return {?}\n */\nexport function createChangeDetectorRef(view: ViewData): ChangeDetectorRef {\n return new ViewRef_(view);\n}\nexport class ViewRef_ implements EmbeddedViewRef<any>, InternalViewRef {\n/**\n * \\@internal\n */\n_view: ViewData;\nprivate _viewContainerRef: ViewContainerRef|null;\nprivate _appRef: ApplicationRef|null;\n/**\n * @param {?} _view\n */\nconstructor(_view: ViewData) {\n this._view = _view;\n this._viewContainerRef = null;\n this._appRef = null;\n }\n/**\n * @return {?}\n */\nget rootNodes(): any[] { return rootRenderNodes(this._view); }\n/**\n * @return {?}\n */\nget context() { return this._view.context; }\n/**\n * @return {?}\n */\nget destroyed(): boolean { return (this._view.state & ViewState.Destroyed) !== 0; }\n/**\n * @return {?}\n */\nmarkForCheck(): void { markParentViewsForCheck(this._view); }\n/**\n * @return {?}\n */\ndetach(): void { this._view.state &= ~ViewState.Attached; }\n/**\n * @return {?}\n */\ndetectChanges(): void { Services.checkAndUpdateView(this._view); }\n/**\n * @return {?}\n */\ncheckNoChanges(): void { Services.checkNoChangesView(this._view); }\n/**\n * @return {?}\n */\nreattach(): void { this._view.state |= ViewState.Attached; }\n/**\n * @param {?} callback\n * @return {?}\n */\nonDestroy(callback: Function) {\n if (!this._view.disposables) {\n this._view.disposables = [];\n }\n this._view.disposables.push( /** @type {?} */((<any>callback)));\n }\n/**\n * @return {?}\n */\ndestroy() {\n if (this._appRef) {\n this._appRef.detachView(this);\n } else if (this._viewContainerRef) {\n this._viewContainerRef.detach(this._viewContainerRef.indexOf(this));\n }\n Services.destroyView(this._view);\n }\n/**\n * @return {?}\n */\ndetachFromAppRef() {\n this._appRef = null;\n renderDetachView(this._view);\n Services.dirtyParentQueries(this._view);\n }\n/**\n * @param {?} appRef\n * @return {?}\n */\nattachToAppRef(appRef: ApplicationRef) {\n if (this._viewContainerRef) {\n throw new Error('This view is already attached to a ViewContainer!');\n }\n this._appRef = appRef;\n }\n/**\n * @param {?} vcRef\n * @return {?}\n */\nattachToViewContainerRef(vcRef: ViewContainerRef) {\n if (this._appRef) {\n throw new Error('This view is already attached directly to the ApplicationRef!');\n }\n this._viewContainerRef = vcRef;\n }\n}\n\nfunction ViewRef__tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\nViewRef_.prototype._view;\n/** @type {?} */\nViewRef_.prototype._viewContainerRef;\n/** @type {?} */\nViewRef_.prototype._appRef;\n}\n\n/**\n * @param {?} view\n * @param {?} def\n * @return {?}\n */\nexport function createTemplateData(view: ViewData, def: NodeDef): TemplateData {\n return new TemplateRef_(view, def);\n}\nclass TemplateRef_ extends TemplateRef<any> implements TemplateData {\n/**\n * \\@internal\n */\n_projectedViews: ViewData[];\n/**\n * @param {?} _parentView\n * @param {?} _def\n */\nconstructor(private _parentView: ViewData,\nprivate _def: NodeDef) { super(); }\n/**\n * @param {?} context\n * @return {?}\n */\ncreateEmbeddedView(context: any): EmbeddedViewRef<any> {\n return new ViewRef_(Services.createEmbeddedView(this._parentView, this._def, context));\n }\n/**\n * @return {?}\n */\nget elementRef(): ElementRef {\n return new ElementRef(asElementData(this._parentView, this._def.index).renderElement);\n }\n}\n\nfunction TemplateRef__tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\nTemplateRef_.prototype._projectedViews;\n/** @type {?} */\nTemplateRef_.prototype._parentView;\n/** @type {?} */\nTemplateRef_.prototype._def;\n}\n\n/**\n * @param {?} view\n * @param {?} elDef\n * @return {?}\n */\nexport function createInjector(view: ViewData, elDef: NodeDef): Injector {\n return new Injector_(view, elDef);\n}\nclass Injector_ implements Injector {\n/**\n * @param {?} view\n * @param {?} elDef\n */\nconstructor(private view: ViewData,\nprivate elDef: NodeDef|null) {}\n/**\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\nget(token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND): any {\n const /** @type {?} */ allowPrivateServices =\n this.elDef ? (this.elDef.flags & NodeFlags.ComponentView) !== 0 : false;\n return Services.resolveDep(\n this.view, this.elDef, allowPrivateServices,\n {flags: DepFlags.None, token, tokenKey: tokenKey(token)}, notFoundValue);\n }\n}\n\nfunction Injector__tsickle_Closure_declarations() {\n/** @type {?} */\nInjector_.prototype.view;\n/** @type {?} */\nInjector_.prototype.elDef;\n}\n\n/**\n * @param {?} view\n * @param {?} index\n * @return {?}\n */\nexport function nodeValue(view: ViewData, index: number): any {\n const /** @type {?} */ def = view.def.nodes[index];\n if (def.flags & NodeFlags.TypeElement) {\n const /** @type {?} */ elData = asElementData(view, def.index);\n return /** @type {?} */(( def.element)).template ? elData.template : elData.renderElement;\n } else if (def.flags & NodeFlags.TypeText) {\n return asTextData(view, def.index).renderText;\n } else if (def.flags & (NodeFlags.CatProvider | NodeFlags.TypePipe)) {\n return asProviderData(view, def.index).instance;\n }\n throw new Error(`Illegal state: read nodeValue for node index ${index}`);\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function createRendererV1(view: ViewData): RendererV1 {\n return new RendererAdapter(view.renderer);\n}\nclass RendererAdapter implements RendererV1 {\n/**\n * @param {?} delegate\n */\nconstructor(private delegate: Renderer2) {}\n/**\n * @param {?} selectorOrNode\n * @return {?}\n */\nselectRootElement(selectorOrNode: string|Element): Element {\n return this.delegate.selectRootElement(selectorOrNode);\n }\n/**\n * @param {?} parent\n * @param {?} namespaceAndName\n * @return {?}\n */\ncreateElement(parent: Element|DocumentFragment, namespaceAndName: string): Element {\n const [ns, name] = splitNamespace(namespaceAndName);\n const /** @type {?} */ el = this.delegate.createElement(name, ns);\n if (parent) {\n this.delegate.appendChild(parent, el);\n }\n return el;\n }\n/**\n * @param {?} hostElement\n * @return {?}\n */\ncreateViewRoot(hostElement: Element): Element|DocumentFragment { return hostElement; }\n/**\n * @param {?} parentElement\n * @return {?}\n */\ncreateTemplateAnchor(parentElement: Element|DocumentFragment): Comment {\n const /** @type {?} */ comment = this.delegate.createComment('');\n if (parentElement) {\n this.delegate.appendChild(parentElement, comment);\n }\n return comment;\n }\n/**\n * @param {?} parentElement\n * @param {?} value\n * @return {?}\n */\ncreateText(parentElement: Element|DocumentFragment, value: string): any {\n const /** @type {?} */ node = this.delegate.createText(value);\n if (parentElement) {\n this.delegate.appendChild(parentElement, node);\n }\n return node;\n }\n/**\n * @param {?} parentElement\n * @param {?} nodes\n * @return {?}\n */\nprojectNodes(parentElement: Element|DocumentFragment, nodes: Node[]) {\n for (let /** @type {?} */ i = 0; i < nodes.length; i++) {\n this.delegate.appendChild(parentElement, nodes[i]);\n }\n }\n/**\n * @param {?} node\n * @param {?} viewRootNodes\n * @return {?}\n */\nattachViewAfter(node: Node, viewRootNodes: Node[]) {\n const /** @type {?} */ parentElement = this.delegate.parentNode(node);\n const /** @type {?} */ nextSibling = this.delegate.nextSibling(node);\n for (let /** @type {?} */ i = 0; i < viewRootNodes.length; i++) {\n this.delegate.insertBefore(parentElement, viewRootNodes[i], nextSibling);\n }\n }\n/**\n * @param {?} viewRootNodes\n * @return {?}\n */\ndetachView(viewRootNodes: (Element|Text|Comment)[]) {\n for (let /** @type {?} */ i = 0; i < viewRootNodes.length; i++) {\n const /** @type {?} */ node = viewRootNodes[i];\n const /** @type {?} */ parentElement = this.delegate.parentNode(node);\n this.delegate.removeChild(parentElement, node);\n }\n }\n/**\n * @param {?} hostElement\n * @param {?} viewAllNodes\n * @return {?}\n */\ndestroyView(hostElement: Element|DocumentFragment, viewAllNodes: Node[]) {\n for (let /** @type {?} */ i = 0; i < viewAllNodes.length; i++) { /** @type {?} */((\n this.delegate.destroyNode))(viewAllNodes[i]);\n }\n }\n/**\n * @param {?} renderElement\n * @param {?} name\n * @param {?} callback\n * @return {?}\n */\nlisten(renderElement: any, name: string, callback: Function): Function {\n return this.delegate.listen(renderElement, name, /** @type {?} */(( <any>callback)));\n }\n/**\n * @param {?} target\n * @param {?} name\n * @param {?} callback\n * @return {?}\n */\nlistenGlobal(target: string, name: string, callback: Function): Function {\n return this.delegate.listen(target, name, /** @type {?} */(( <any>callback)));\n }\n/**\n * @param {?} renderElement\n * @param {?} propertyName\n * @param {?} propertyValue\n * @return {?}\n */\nsetElementProperty(\n renderElement: Element|DocumentFragment, propertyName: string, propertyValue: any): void {\n this.delegate.setProperty(renderElement, propertyName, propertyValue);\n }\n/**\n * @param {?} renderElement\n * @param {?} namespaceAndName\n * @param {?} attributeValue\n * @return {?}\n */\nsetElementAttribute(renderElement: Element, namespaceAndName: string, attributeValue: string):\n void {\n const [ns, name] = splitNamespace(namespaceAndName);\n if (attributeValue != null) {\n this.delegate.setAttribute(renderElement, name, attributeValue, ns);\n } else {\n this.delegate.removeAttribute(renderElement, name, ns);\n }\n }\n/**\n * @param {?} renderElement\n * @param {?} propertyName\n * @param {?} propertyValue\n * @return {?}\n */\nsetBindingDebugInfo(renderElement: Element, propertyName: string, propertyValue: string): void {}\n/**\n * @param {?} renderElement\n * @param {?} className\n * @param {?} isAdd\n * @return {?}\n */\nsetElementClass(renderElement: Element, className: string, isAdd: boolean): void {\n if (isAdd) {\n this.delegate.addClass(renderElement, className);\n } else {\n this.delegate.removeClass(renderElement, className);\n }\n }\n/**\n * @param {?} renderElement\n * @param {?} styleName\n * @param {?} styleValue\n * @return {?}\n */\nsetElementStyle(renderElement: HTMLElement, styleName: string, styleValue: string): void {\n if (styleValue != null) {\n this.delegate.setStyle(renderElement, styleName, styleValue);\n } else {\n this.delegate.removeStyle(renderElement, styleName);\n }\n }\n/**\n * @param {?} renderElement\n * @param {?} methodName\n * @param {?} args\n * @return {?}\n */\ninvokeElementMethod(renderElement: Element, methodName: string, args: any[]): void {\n ( /** @type {?} */((renderElement as any)))[methodName].apply(renderElement, args);\n }\n/**\n * @param {?} renderNode\n * @param {?} text\n * @return {?}\n */\nsetText(renderNode: Text, text: string): void { this.delegate.setValue(renderNode, text); }\n/**\n * @return {?}\n */\nanimate(): any { throw new Error('Renderer.animate is no longer supported!'); }\n}\n\nfunction RendererAdapter_tsickle_Closure_declarations() {\n/** @type {?} */\nRendererAdapter.prototype.delegate;\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} from '../di/injector';\nimport {ComponentFactory, ComponentRef} from './component_factory';\nimport {ElementRef} from './element_ref';\nimport {NgModuleRef} from './ng_module_factory';\nimport {TemplateRef} from './template_ref';\nimport {EmbeddedViewRef, ViewRef} from './view_ref';\n/**\n * Represents a container where one or more Views can be attached.\n * \n * The container can contain two kinds of Views. Host Views, created by instantiating a\n * {\\@link Component} via {\\@link #createComponent}, and Embedded Views, created by instantiating an\n * {\\@link TemplateRef Embedded Template} via {\\@link #createEmbeddedView}.\n * \n * The location of the View Container within the containing View is specified by the Anchor\n * `element`. Each View Container can have only one Anchor Element and each Anchor Element can only\n * have a single View Container.\n * \n * Root elements of Views attached to this container become siblings of the Anchor Element in\n * the Rendered View.\n * \n * To access a `ViewContainerRef` of an Element, you can either place a {\\@link Directive} injected\n * with `ViewContainerRef` on the Element, or you obtain it via a {\\@link ViewChild} query.\n * \\@stable\n * @abstract\n */\nexport abstract class ViewContainerRef {\n/**\n * Anchor element that specifies the location of this container in the containing View.\n * <!-- TODO: rename to anchorElement -->\n * @abstract\n * @return {?}\n */\nelement() {}\n/**\n * @abstract\n * @return {?}\n */\ninjector() {}\n/**\n * @abstract\n * @return {?}\n */\nparentInjector() {}\n/**\n * Destroys all Views in this container.\n * @abstract\n * @return {?}\n */\nclear() {}\n/**\n * Returns the {\\@link ViewRef} for the View located in this container at the specified index.\n * @abstract\n * @param {?} index\n * @return {?}\n */\nget(index: number) {}\n/**\n * Returns the number of Views currently attached to this container.\n * @abstract\n * @return {?}\n */\nlength() {}\n/**\n * Instantiates an Embedded View based on the {\\@link TemplateRef `templateRef`} and inserts it\n * into this container at the specified `index`.\n * \n * If `index` is not specified, the new View will be inserted as the last View in the container.\n * \n * Returns the {\\@link ViewRef} for the newly created View.\n * @abstract\n * @template C\n * @param {?} templateRef\n * @param {?=} context\n * @param {?=} index\n * @return {?}\n */\ncreateEmbeddedView<C>(templateRef: TemplateRef<C>, context?: C, index?: number) {}\n/**\n * Instantiates a single {\\@link Component} and inserts its Host View into this container at the\n * specified `index`.\n * \n * The component is instantiated using its {\\@link ComponentFactory} which can be\n * obtained via {\\@link ComponentFactoryResolver#resolveComponentFactory}.\n * \n * If `index` is not specified, the new View will be inserted as the last View in the container.\n * \n * You can optionally specify the {\\@link Injector} that will be used as parent for the Component.\n * \n * Returns the {\\@link ComponentRef} of the Host View created for the newly instantiated Component.\n * @abstract\n * @template C\n * @param {?} componentFactory\n * @param {?=} index\n * @param {?=} injector\n * @param {?=} projectableNodes\n * @param {?=} ngModule\n * @return {?}\n */\ncreateComponent<C>(\n componentFactory: ComponentFactory<C>, index?: number, injector?: Injector,\n projectableNodes?: any[][], ngModule?: NgModuleRef<any>) {}\n/**\n * Inserts a View identified by a {\\@link ViewRef} into the container at the specified `index`.\n * \n * If `index` is not specified, the new View will be inserted as the last View in the container.\n * \n * Returns the inserted {\\@link ViewRef}.\n * @abstract\n * @param {?} viewRef\n * @param {?=} index\n * @return {?}\n */\ninsert(viewRef: ViewRef, index?: number) {}\n/**\n * Moves a View identified by a {\\@link ViewRef} into the container at the specified `index`.\n * \n * Returns the inserted {\\@link ViewRef}.\n * @abstract\n * @param {?} viewRef\n * @param {?} currentIndex\n * @return {?}\n */\nmove(viewRef: ViewRef, currentIndex: number) {}\n/**\n * Returns the index of the View, specified via {\\@link ViewRef}, within the current container or\n * `-1` if this container doesn't contain the View.\n * @abstract\n * @param {?} viewRef\n * @return {?}\n */\nindexOf(viewRef: ViewRef) {}\n/**\n * Destroys a View attached to this container at the specified `index`.\n * \n * If `index` is not specified, the last View in the container will be removed.\n * @abstract\n * @param {?=} index\n * @return {?}\n */\nremove(index?: number) {}\n/**\n * Use along with {\\@link #insert} to move a View within the current container.\n * \n * If the `index` param is omitted, the last {\\@link ViewRef} is detached.\n * @abstract\n * @param {?=} index\n * @return {?}\n */\ndetach(index?: number) {}\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} from '../di';\nimport {DebugContext} from '../view/index';\nexport class EventListener {\n/**\n * @param {?} name\n * @param {?} callback\n */\nconstructor(public name: string,\npublic callback: Function){}; }\n\nfunction EventListener_tsickle_Closure_declarations() {\n/** @type {?} */\nEventListener.prototype.name;\n/** @type {?} */\nEventListener.prototype.callback;\n}\n\n/**\n * \\@experimental All debugging apis are currently experimental.\n */\nexport class DebugNode {\n nativeNode: any;\n listeners: EventListener[];\n parent: DebugElement|null;\n/**\n * @param {?} nativeNode\n * @param {?} parent\n * @param {?} _debugContext\n */\nconstructor(nativeNode: any, parent: DebugNode|null,\nprivate _debugContext: DebugContext) {\n this.nativeNode = nativeNode;\n if (parent && parent instanceof DebugElement) {\n parent.addChild(this);\n } else {\n this.parent = null;\n }\n this.listeners = [];\n }\n/**\n * @return {?}\n */\nget injector(): Injector { return this._debugContext.injector; }\n/**\n * @return {?}\n */\nget componentInstance(): any { return this._debugContext.component; }\n/**\n * @return {?}\n */\nget context(): any { return this._debugContext.context; }\n/**\n * @return {?}\n */\nget references(): {[key: string]: any} { return this._debugContext.references; }\n/**\n * @return {?}\n */\nget providerTokens(): any[] { return this._debugContext.providerTokens; }\n/**\n * @deprecated since v4\n * @return {?}\n */\nget source(): string { return 'Deprecated since v4'; }\n}\n\nfunction DebugNode_tsickle_Closure_declarations() {\n/** @type {?} */\nDebugNode.prototype.nativeNode;\n/** @type {?} */\nDebugNode.prototype.listeners;\n/** @type {?} */\nDebugNode.prototype.parent;\n/** @type {?} */\nDebugNode.prototype._debugContext;\n}\n\n/**\n * \\@experimental All debugging apis are currently experimental.\n */\nexport class DebugElement extends DebugNode {\n name: string;\n properties: {[key: string]: any};\n attributes: {[key: string]: string | null};\n classes: {[key: string]: boolean};\n styles: {[key: string]: string | null};\n childNodes: DebugNode[];\n nativeElement: any;\n/**\n * @param {?} nativeNode\n * @param {?} parent\n * @param {?} _debugContext\n */\nconstructor(nativeNode: any, parent: any, _debugContext: DebugContext) {\n super(nativeNode, parent, _debugContext);\n this.properties = {};\n this.attributes = {};\n this.classes = {};\n this.styles = {};\n this.childNodes = [];\n this.nativeElement = nativeNode;\n }\n/**\n * @param {?} child\n * @return {?}\n */\naddChild(child: DebugNode) {\n if (child) {\n this.childNodes.push(child);\n child.parent = this;\n }\n }\n/**\n * @param {?} child\n * @return {?}\n */\nremoveChild(child: DebugNode) {\n const /** @type {?} */ childIndex = this.childNodes.indexOf(child);\n if (childIndex !== -1) {\n child.parent = null;\n this.childNodes.splice(childIndex, 1);\n }\n }\n/**\n * @param {?} child\n * @param {?} newChildren\n * @return {?}\n */\ninsertChildrenAfter(child: DebugNode, newChildren: DebugNode[]) {\n const /** @type {?} */ siblingIndex = this.childNodes.indexOf(child);\n if (siblingIndex !== -1) {\n this.childNodes.splice(siblingIndex + 1, 0, ...newChildren);\n newChildren.forEach(c => {\n if (c.parent) {\n c.parent.removeChild(c);\n }\n c.parent = this;\n });\n }\n }\n/**\n * @param {?} refChild\n * @param {?} newChild\n * @return {?}\n */\ninsertBefore(refChild: DebugNode, newChild: DebugNode): void {\n const /** @type {?} */ refIndex = this.childNodes.indexOf(refChild);\n if (refIndex === -1) {\n this.addChild(newChild);\n } else {\n if (newChild.parent) {\n newChild.parent.removeChild(newChild);\n }\n newChild.parent = this;\n this.childNodes.splice(refIndex, 0, newChild);\n }\n }\n/**\n * @param {?} predicate\n * @return {?}\n */\nquery(predicate: Predicate<DebugElement>): DebugElement {\n const /** @type {?} */ results = this.queryAll(predicate);\n return results[0] || null;\n }\n/**\n * @param {?} predicate\n * @return {?}\n */\nqueryAll(predicate: Predicate<DebugElement>): DebugElement[] {\n const /** @type {?} */ matches: DebugElement[] = [];\n _queryElementChildren(this, predicate, matches);\n return matches;\n }\n/**\n * @param {?} predicate\n * @return {?}\n */\nqueryAllNodes(predicate: Predicate<DebugNode>): DebugNode[] {\n const /** @type {?} */ matches: DebugNode[] = [];\n _queryNodeChildren(this, predicate, matches);\n return matches;\n }\n/**\n * @return {?}\n */\nget children(): DebugElement[] {\n return /** @type {?} */(( this.childNodes.filter((node) => node instanceof DebugElement) as DebugElement[]));\n }\n/**\n * @param {?} eventName\n * @param {?} eventObj\n * @return {?}\n */\ntriggerEventHandler(eventName: string, eventObj: any) {\n this.listeners.forEach((listener) => {\n if (listener.name == eventName) {\n listener.callback(eventObj);\n }\n });\n }\n}\n\nfunction DebugElement_tsickle_Closure_declarations() {\n/** @type {?} */\nDebugElement.prototype.name;\n/** @type {?} */\nDebugElement.prototype.properties;\n/** @type {?} */\nDebugElement.prototype.attributes;\n/** @type {?} */\nDebugElement.prototype.classes;\n/** @type {?} */\nDebugElement.prototype.styles;\n/** @type {?} */\nDebugElement.prototype.childNodes;\n/** @type {?} */\nDebugElement.prototype.nativeElement;\n}\n\n/**\n * \\@experimental\n * @param {?} debugEls\n * @return {?}\n */\nexport function asNativeElements(debugEls: DebugElement[]): any {\n return debugEls.map((el) => el.nativeElement);\n}\n/**\n * @param {?} element\n * @param {?} predicate\n * @param {?} matches\n * @return {?}\n */\nfunction _queryElementChildren(\n element: DebugElement, predicate: Predicate<DebugElement>, matches: DebugElement[]) {\n element.childNodes.forEach(node => {\n if (node instanceof DebugElement) {\n if (predicate(node)) {\n matches.push(node);\n }\n _queryElementChildren(node, predicate, matches);\n }\n });\n}\n/**\n * @param {?} parentNode\n * @param {?} predicate\n * @param {?} matches\n * @return {?}\n */\nfunction _queryNodeChildren(\n parentNode: DebugNode, predicate: Predicate<DebugNode>, matches: DebugNode[]) {\n if (parentNode instanceof DebugElement) {\n parentNode.childNodes.forEach(node => {\n if (predicate(node)) {\n matches.push(node);\n }\n if (node instanceof DebugElement) {\n _queryNodeChildren(node, predicate, matches);\n }\n });\n }\n}\n\n// Need to keep the nodes in a global Map so that multiple angular apps are supported.\nconst /** @type {?} */ _nativeNodeToDebugNode = new Map<any, DebugNode>();\n/**\n * \\@experimental\n * @param {?} nativeNode\n * @return {?}\n */\nexport function getDebugNode(nativeNode: any): DebugNode|null {\n return _nativeNodeToDebugNode.get(nativeNode) || null;\n}\n/**\n * @return {?}\n */\nexport function getAllDebugNodes(): DebugNode[] {\n return Array.from(_nativeNodeToDebugNode.values());\n}\n/**\n * @param {?} node\n * @return {?}\n */\nexport function indexDebugNode(node: DebugNode) {\n _nativeNodeToDebugNode.set(node.nativeNode, node);\n}\n/**\n * @param {?} node\n * @return {?}\n */\nexport function removeDebugNodeFromIndex(node: DebugNode) {\n _nativeNodeToDebugNode.delete(node.nativeNode);\n}\n\n/**\n * A boolean-valued function over a value, possibly including context information\n * regarding that value's position in an array.\n *\n * @experimental All debugging apis are currently experimental.\n */\nexport interface Predicate<T> { (value: T): boolean; }\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 {getSymbolIterator, looseIdentical} from '../util';\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nexport function devModeEqual(a: any, b: any): boolean {\n const /** @type {?} */ isListLikeIterableA = isListLikeIterable(a);\n const /** @type {?} */ isListLikeIterableB = isListLikeIterable(b);\n if (isListLikeIterableA && isListLikeIterableB) {\n return areIterablesEqual(a, b, devModeEqual);\n } else {\n const /** @type {?} */ isAObject = a && (typeof a === 'object' || typeof a === 'function');\n const /** @type {?} */ isBObject = b && (typeof b === 'object' || typeof b === 'function');\n if (!isListLikeIterableA && isAObject && !isListLikeIterableB && isBObject) {\n return true;\n } else {\n return looseIdentical(a, b);\n }\n }\n}\n/**\n * Indicates that the result of a {\\@link Pipe} transformation has changed even though the\n * reference\n * has not changed.\n * \n * The wrapped value will be unwrapped by change detection, and the unwrapped value will be stored.\n * \n * Example:\n * \n * ```\n * if (this._latestValue === this._latestReturnedValue) {\n * return this._latestReturnedValue;\n * } else {\n * this._latestReturnedValue = this._latestValue;\n * return WrappedValue.wrap(this._latestValue); // this will force update\n * }\n * ```\n * \\@stable\n */\nexport class WrappedValue {\n/**\n * @param {?} wrapped\n */\nconstructor(public wrapped: any) {}\n/**\n * @param {?} value\n * @return {?}\n */\nstatic wrap(value: any): WrappedValue { return new WrappedValue(value); }\n}\n\nfunction WrappedValue_tsickle_Closure_declarations() {\n/** @type {?} */\nWrappedValue.prototype.wrapped;\n}\n\n/**\n * Helper class for unwrapping WrappedValue s\n */\nexport class ValueUnwrapper {\npublic hasWrappedValue = false;\n/**\n * @param {?} value\n * @return {?}\n */\nunwrap(value: any): any {\n if (value instanceof WrappedValue) {\n this.hasWrappedValue = true;\n return value.wrapped;\n }\n return value;\n }\n/**\n * @return {?}\n */\nreset() { this.hasWrappedValue = false; }\n}\n\nfunction ValueUnwrapper_tsickle_Closure_declarations() {\n/** @type {?} */\nValueUnwrapper.prototype.hasWrappedValue;\n}\n\n/**\n * Represents a basic change from a previous to a new value.\n * \\@stable\n */\nexport class SimpleChange {\n/**\n * @param {?} previousValue\n * @param {?} currentValue\n * @param {?} firstChange\n */\nconstructor(public previousValue: any,\npublic currentValue: any,\npublic firstChange: boolean) {}\n/**\n * Check whether the new value is the first value assigned.\n * @return {?}\n */\nisFirstChange(): boolean { return this.firstChange; }\n}\n\nfunction SimpleChange_tsickle_Closure_declarations() {\n/** @type {?} */\nSimpleChange.prototype.previousValue;\n/** @type {?} */\nSimpleChange.prototype.currentValue;\n/** @type {?} */\nSimpleChange.prototype.firstChange;\n}\n\n/**\n * @param {?} obj\n * @return {?}\n */\nexport function isListLikeIterable(obj: any): boolean {\n if (!isJsObject(obj)) return false;\n return Array.isArray(obj) ||\n (!(obj instanceof Map) && // JS Map are iterables but return entries as [k, v]\n getSymbolIterator() in obj); // JS Iterable have a Symbol.iterator prop\n}\n/**\n * @param {?} a\n * @param {?} b\n * @param {?} comparator\n * @return {?}\n */\nexport function areIterablesEqual(\n a: any, b: any, comparator: (a: any, b: any) => boolean): boolean {\n const /** @type {?} */ iterator1 = a[getSymbolIterator()]();\n const /** @type {?} */ iterator2 = b[getSymbolIterator()]();\n\n while (true) {\n const /** @type {?} */ item1 = iterator1.next();\n const /** @type {?} */ item2 = iterator2.next();\n if (item1.done && item2.done) return true;\n if (item1.done || item2.done) return false;\n if (!comparator(item1.value, item2.value)) return false;\n }\n}\n/**\n * @param {?} obj\n * @param {?} fn\n * @return {?}\n */\nexport function iterateListLike(obj: any, fn: (p: any) => any) {\n if (Array.isArray(obj)) {\n for (let /** @type {?} */ i = 0; i < obj.length; i++) {\n fn(obj[i]);\n }\n } else {\n const /** @type {?} */ iterator = obj[getSymbolIterator()]();\n let /** @type {?} */ item: any;\n while (!((item = iterator.next()).done)) {\n fn(item.value);\n }\n }\n}\n/**\n * @param {?} o\n * @return {?}\n */\nexport function isJsObject(o: any): boolean {\n return o !== null && (typeof o === 'function' || typeof o === 'object');\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 {looseIdentical, stringify} from '../../util';\nimport {isListLikeIterable, iterateListLike} from '../change_detection_util';\nimport {ChangeDetectorRef} from '../change_detector_ref';\n\nimport {IterableChangeRecord, IterableChanges, IterableDiffer, IterableDifferFactory, NgIterable, TrackByFunction} from './iterable_differs';\nexport class DefaultIterableDifferFactory implements IterableDifferFactory {\nconstructor() {}\n/**\n * @param {?} obj\n * @return {?}\n */\nsupports(obj: Object|null|undefined): boolean { return isListLikeIterable(obj); }\n\n create<V>(trackByFn?: TrackByFunction<V>): DefaultIterableDiffer<V>;\n/**\n * @deprecated v4.0.0 - ChangeDetectorRef is not used and is no longer a parameter\n * @template V\n * @param {?=} cdRefOrTrackBy\n * @param {?=} trackByFn\n * @return {?}\n */\ncreate<V>(cdRefOrTrackBy?: ChangeDetectorRef|TrackByFunction<V>, trackByFn?: TrackByFunction<V>):\n DefaultIterableDiffer<V> {\n return new DefaultIterableDiffer<V>(trackByFn || /** @type {?} */(( <TrackByFunction<any>>cdRefOrTrackBy)));\n }\n}\n\nconst /** @type {?} */ trackByIdentity = (index: number, item: any) => item;\n/**\n * @deprecated v4.0.0 - Should not be part of public API.\n */\nexport class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChanges<V> {\nprivate _length: number = 0;\nprivate _collection: NgIterable<V>|null = null;\nprivate _linkedRecords: _DuplicateMap<V>|null = null;\nprivate _unlinkedRecords: _DuplicateMap<V>|null = null;\nprivate _previousItHead: IterableChangeRecord_<V>|null = null;\nprivate _itHead: IterableChangeRecord_<V>|null = null;\nprivate _itTail: IterableChangeRecord_<V>|null = null;\nprivate _additionsHead: IterableChangeRecord_<V>|null = null;\nprivate _additionsTail: IterableChangeRecord_<V>|null = null;\nprivate _movesHead: IterableChangeRecord_<V>|null = null;\nprivate _movesTail: IterableChangeRecord_<V>|null = null;\nprivate _removalsHead: IterableChangeRecord_<V>|null = null;\nprivate _removalsTail: IterableChangeRecord_<V>|null = null;\nprivate _identityChangesHead: IterableChangeRecord_<V>|null = null;\nprivate _identityChangesTail: IterableChangeRecord_<V>|null = null;\nprivate _trackByFn: TrackByFunction<V>\n/**\n * @param {?=} trackByFn\n */\nconstructor(trackByFn?: TrackByFunction<V>) {\n this._trackByFn = trackByFn || trackByIdentity;\n }\n/**\n * @return {?}\n */\nget collection() { return this._collection; }\n/**\n * @return {?}\n */\nget length(): number { return this._length; }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachItem(fn: (record: IterableChangeRecord_<V>) => void) {\n let /** @type {?} */ record: IterableChangeRecord_<V>|null;\n for (record = this._itHead; record !== null; record = record._next) {\n fn(record);\n }\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachOperation(\n fn: (item: IterableChangeRecord<V>, previousIndex: number|null, currentIndex: number|null) =>\n void) {\n let /** @type {?} */ nextIt = this._itHead;\n let /** @type {?} */ nextRemove = this._removalsHead;\n let /** @type {?} */ addRemoveOffset = 0;\n let /** @type {?} */ moveOffsets: number[]|null = null;\n while (nextIt || nextRemove) {\n // Figure out which is the next record to process\n // Order: remove, add, move\n const /** @type {?} */ record: IterableChangeRecord<V> = !nextRemove ||\n nextIt && /** @type {?} */((\n nextIt.currentIndex)) <\n getPreviousIndex(nextRemove, addRemoveOffset, moveOffsets) ? /** @type {?} */((\n nextIt)) :\n nextRemove;\n const /** @type {?} */ adjPreviousIndex = getPreviousIndex(record, addRemoveOffset, moveOffsets);\n const /** @type {?} */ currentIndex = record.currentIndex;\n\n // consume the item, and adjust the addRemoveOffset and update moveDistance if necessary\n if (record === nextRemove) {\n addRemoveOffset--;\n nextRemove = nextRemove._nextRemoved;\n } else {\n nextIt = /** @type {?} */(( nextIt))._next;\n if (record.previousIndex == null) {\n addRemoveOffset++;\n } else {\n // INVARIANT: currentIndex < previousIndex\n if (!moveOffsets) moveOffsets = [];\n const /** @type {?} */ localMovePreviousIndex = adjPreviousIndex - addRemoveOffset;\n const /** @type {?} */ localCurrentIndex = /** @type {?} */(( currentIndex)) - addRemoveOffset;\n if (localMovePreviousIndex != localCurrentIndex) {\n for (let /** @type {?} */ i = 0; i < localMovePreviousIndex; i++) {\n const /** @type {?} */ offset = i < moveOffsets.length ? moveOffsets[i] : (moveOffsets[i] = 0);\n const /** @type {?} */ index = offset + i;\n if (localCurrentIndex <= index && index < localMovePreviousIndex) {\n moveOffsets[i] = offset + 1;\n }\n }\n const /** @type {?} */ previousIndex = record.previousIndex;\n moveOffsets[previousIndex] = localCurrentIndex - localMovePreviousIndex;\n }\n }\n }\n\n if (adjPreviousIndex !== currentIndex) {\n fn(record, adjPreviousIndex, currentIndex);\n }\n }\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachPreviousItem(fn: (record: IterableChangeRecord_<V>) => void) {\n let /** @type {?} */ record: IterableChangeRecord_<V>|null;\n for (record = this._previousItHead; record !== null; record = record._nextPrevious) {\n fn(record);\n }\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachAddedItem(fn: (record: IterableChangeRecord_<V>) => void) {\n let /** @type {?} */ record: IterableChangeRecord_<V>|null;\n for (record = this._additionsHead; record !== null; record = record._nextAdded) {\n fn(record);\n }\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachMovedItem(fn: (record: IterableChangeRecord_<V>) => void) {\n let /** @type {?} */ record: IterableChangeRecord_<V>|null;\n for (record = this._movesHead; record !== null; record = record._nextMoved) {\n fn(record);\n }\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachRemovedItem(fn: (record: IterableChangeRecord_<V>) => void) {\n let /** @type {?} */ record: IterableChangeRecord_<V>|null;\n for (record = this._removalsHead; record !== null; record = record._nextRemoved) {\n fn(record);\n }\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachIdentityChange(fn: (record: IterableChangeRecord_<V>) => void) {\n let /** @type {?} */ record: IterableChangeRecord_<V>|null;\n for (record = this._identityChangesHead; record !== null; record = record._nextIdentityChange) {\n fn(record);\n }\n }\n/**\n * @param {?} collection\n * @return {?}\n */\ndiff(collection: NgIterable<V>): DefaultIterableDiffer<V>|null {\n if (collection == null) collection = [];\n if (!isListLikeIterable(collection)) {\n throw new Error(\n `Error trying to diff '${stringify(collection)}'. Only arrays and iterables are allowed`);\n }\n\n if (this.check(collection)) {\n return this;\n } else {\n return null;\n }\n }\n/**\n * @return {?}\n */\nonDestroy() {}\n/**\n * @param {?} collection\n * @return {?}\n */\ncheck(collection: NgIterable<V>): boolean {\n this._reset();\n\n let /** @type {?} */ record: IterableChangeRecord_<V>|null = this._itHead;\n let /** @type {?} */ mayBeDirty: boolean = false;\n let /** @type {?} */ index: number;\n let /** @type {?} */ item: V;\n let /** @type {?} */ itemTrackBy: any;\n if (Array.isArray(collection)) {\n this._length = collection.length;\n\n for (let /** @type {?} */ index = 0; index < this._length; index++) {\n item = collection[index];\n itemTrackBy = this._trackByFn(index, item);\n if (record === null || !looseIdentical(record.trackById, itemTrackBy)) {\n record = this._mismatch(record, item, itemTrackBy, index);\n mayBeDirty = true;\n } else {\n if (mayBeDirty) {\n // TODO(misko): can we limit this to duplicates only?\n record = this._verifyReinsertion(record, item, itemTrackBy, index);\n }\n if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);\n }\n\n record = record._next;\n }\n } else {\n index = 0;\n iterateListLike(collection, (item: V) => {\n itemTrackBy = this._trackByFn(index, item);\n if (record === null || !looseIdentical(record.trackById, itemTrackBy)) {\n record = this._mismatch(record, item, itemTrackBy, index);\n mayBeDirty = true;\n } else {\n if (mayBeDirty) {\n // TODO(misko): can we limit this to duplicates only?\n record = this._verifyReinsertion(record, item, itemTrackBy, index);\n }\n if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);\n }\n record = record._next;\n index++;\n });\n this._length = index;\n }\n\n this._truncate(record);\n this._collection = collection;\n return this.isDirty;\n }\n/**\n * @return {?}\n */\nget isDirty(): boolean {\n return this._additionsHead !== null || this._movesHead !== null ||\n this._removalsHead !== null || this._identityChangesHead !== null;\n }\n/**\n * Reset the state of the change objects to show no changes. This means set previousKey to\n * currentKey, and clear all of the queues (additions, moves, removals).\n * Set the previousIndexes of moved and added items to their currentIndexes\n * Reset the list of additions, moves and removals\n * \n * \\@internal\n * @return {?}\n */\n_reset() {\n if (this.isDirty) {\n let /** @type {?} */ record: IterableChangeRecord_<V>|null;\n let /** @type {?} */ nextRecord: IterableChangeRecord_<V>|null;\n\n for (record = this._previousItHead = this._itHead; record !== null; record = record._next) {\n record._nextPrevious = record._next;\n }\n\n for (record = this._additionsHead; record !== null; record = record._nextAdded) {\n record.previousIndex = record.currentIndex;\n }\n this._additionsHead = this._additionsTail = null;\n\n for (record = this._movesHead; record !== null; record = nextRecord) {\n record.previousIndex = record.currentIndex;\n nextRecord = record._nextMoved;\n }\n this._movesHead = this._movesTail = null;\n this._removalsHead = this._removalsTail = null;\n this._identityChangesHead = this._identityChangesTail = null;\n\n // todo(vicb) when assert gets supported\n // assert(!this.isDirty);\n }\n }\n/**\n * This is the core function which handles differences between collections.\n * \n * - `record` is the record which we saw at this position last time. If null then it is a new\n * item.\n * - `item` is the current item in the collection\n * - `index` is the position of the item in the collection\n * \n * \\@internal\n * @param {?} record\n * @param {?} item\n * @param {?} itemTrackBy\n * @param {?} index\n * @return {?}\n */\n_mismatch(record: IterableChangeRecord_<V>|null, item: V, itemTrackBy: any, index: number):\n IterableChangeRecord_<V> {\n // The previous record after which we will append the current one.\n let /** @type {?} */ previousRecord: IterableChangeRecord_<V>;\n\n if (record === null) {\n previousRecord = /** @type {?} */(( this._itTail));\n } else {\n previousRecord = /** @type {?} */(( record._prev));\n // Remove the record from the collection since we know it does not match the item.\n this._remove(record);\n }\n\n // Attempt to see if we have seen the item before.\n record = this._linkedRecords === null ? null : this._linkedRecords.get(itemTrackBy, index);\n if (record !== null) {\n // We have seen this before, we need to move it forward in the collection.\n // But first we need to check if identity changed, so we can update in view if necessary\n if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);\n\n this._moveAfter(record, previousRecord, index);\n } else {\n // Never seen it, check evicted list.\n record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);\n if (record !== null) {\n // It is an item which we have evicted earlier: reinsert it back into the list.\n // But first we need to check if identity changed, so we can update in view if necessary\n if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);\n\n this._reinsertAfter(record, previousRecord, index);\n } else {\n // It is a new item: add it.\n record =\n this._addAfter(new IterableChangeRecord_<V>(item, itemTrackBy), previousRecord, index);\n }\n }\n return record;\n }\n/**\n * This check is only needed if an array contains duplicates. (Short circuit of nothing dirty)\n * \n * Use case: `[a, a]` => `[b, a, a]`\n * \n * If we did not have this check then the insertion of `b` would:\n * 1) evict first `a`\n * 2) insert `b` at `0` index.\n * 3) leave `a` at index `1` as is. <-- this is wrong!\n * 3) reinsert `a` at index 2. <-- this is wrong!\n * \n * The correct behavior is:\n * 1) evict first `a`\n * 2) insert `b` at `0` index.\n * 3) reinsert `a` at index 1.\n * 3) move `a` at from `1` to `2`.\n * \n * \n * Double check that we have not evicted a duplicate item. We need to check if the item type may\n * have already been removed:\n * The insertion of b will evict the first 'a'. If we don't reinsert it now it will be reinserted\n * at the end. Which will show up as the two 'a's switching position. This is incorrect, since a\n * better way to think of it is as insert of 'b' rather then switch 'a' with 'b' and then add 'a'\n * at the end.\n * \n * \\@internal\n * @param {?} record\n * @param {?} item\n * @param {?} itemTrackBy\n * @param {?} index\n * @return {?}\n */\n_verifyReinsertion(record: IterableChangeRecord_<V>, item: V, itemTrackBy: any, index: number):\n IterableChangeRecord_<V> {\n let /** @type {?} */ reinsertRecord: IterableChangeRecord_<V>|null =\n this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);\n if (reinsertRecord !== null) {\n record = this._reinsertAfter(reinsertRecord, /** @type {?} */(( record._prev)), index);\n } else if (record.currentIndex != index) {\n record.currentIndex = index;\n this._addToMoves(record, index);\n }\n return record;\n }\n/**\n * Get rid of any excess {\\@link IterableChangeRecord_}s from the previous collection\n * \n * - `record` The first excess {\\@link IterableChangeRecord_}.\n * \n * \\@internal\n * @param {?} record\n * @return {?}\n */\n_truncate(record: IterableChangeRecord_<V>|null) {\n // Anything after that needs to be removed;\n while (record !== null) {\n const /** @type {?} */ nextRecord: IterableChangeRecord_<V>|null = record._next;\n this._addToRemovals(this._unlink(record));\n record = nextRecord;\n }\n if (this._unlinkedRecords !== null) {\n this._unlinkedRecords.clear();\n }\n\n if (this._additionsTail !== null) {\n this._additionsTail._nextAdded = null;\n }\n if (this._movesTail !== null) {\n this._movesTail._nextMoved = null;\n }\n if (this._itTail !== null) {\n this._itTail._next = null;\n }\n if (this._removalsTail !== null) {\n this._removalsTail._nextRemoved = null;\n }\n if (this._identityChangesTail !== null) {\n this._identityChangesTail._nextIdentityChange = null;\n }\n }\n/**\n * \\@internal\n * @param {?} record\n * @param {?} prevRecord\n * @param {?} index\n * @return {?}\n */\n_reinsertAfter(\n record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>,\n index: number): IterableChangeRecord_<V> {\n if (this._unlinkedRecords !== null) {\n this._unlinkedRecords.remove(record);\n }\n const /** @type {?} */ prev = record._prevRemoved;\n const /** @type {?} */ next = record._nextRemoved;\n\n if (prev === null) {\n this._removalsHead = next;\n } else {\n prev._nextRemoved = next;\n }\n if (next === null) {\n this._removalsTail = prev;\n } else {\n next._prevRemoved = prev;\n }\n\n this._insertAfter(record, prevRecord, index);\n this._addToMoves(record, index);\n return record;\n }\n/**\n * \\@internal\n * @param {?} record\n * @param {?} prevRecord\n * @param {?} index\n * @return {?}\n */\n_moveAfter(record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>, index: number):\n IterableChangeRecord_<V> {\n this._unlink(record);\n this._insertAfter(record, prevRecord, index);\n this._addToMoves(record, index);\n return record;\n }\n/**\n * \\@internal\n * @param {?} record\n * @param {?} prevRecord\n * @param {?} index\n * @return {?}\n */\n_addAfter(record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>, index: number):\n IterableChangeRecord_<V> {\n this._insertAfter(record, prevRecord, index);\n\n if (this._additionsTail === null) {\n // todo(vicb)\n // assert(this._additionsHead === null);\n this._additionsTail = this._additionsHead = record;\n } else {\n // todo(vicb)\n // assert(_additionsTail._nextAdded === null);\n // assert(record._nextAdded === null);\n this._additionsTail = this._additionsTail._nextAdded = record;\n }\n return record;\n }\n/**\n * \\@internal\n * @param {?} record\n * @param {?} prevRecord\n * @param {?} index\n * @return {?}\n */\n_insertAfter(\n record: IterableChangeRecord_<V>, prevRecord: IterableChangeRecord_<V>,\n index: number): IterableChangeRecord_<V> {\n // todo(vicb)\n // assert(record != prevRecord);\n // assert(record._next === null);\n // assert(record._prev === null);\n\n const /** @type {?} */ next: IterableChangeRecord_<V>|null =\n prevRecord === null ? this._itHead : prevRecord._next;\n // todo(vicb)\n // assert(next != record);\n // assert(prevRecord != record);\n record._next = next;\n record._prev = prevRecord;\n if (next === null) {\n this._itTail = record;\n } else {\n next._prev = record;\n }\n if (prevRecord === null) {\n this._itHead = record;\n } else {\n prevRecord._next = record;\n }\n\n if (this._linkedRecords === null) {\n this._linkedRecords = new _DuplicateMap<V>();\n }\n this._linkedRecords.put(record);\n\n record.currentIndex = index;\n return record;\n }\n/**\n * \\@internal\n * @param {?} record\n * @return {?}\n */\n_remove(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {\n return this._addToRemovals(this._unlink(record));\n }\n/**\n * \\@internal\n * @param {?} record\n * @return {?}\n */\n_unlink(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {\n if (this._linkedRecords !== null) {\n this._linkedRecords.remove(record);\n }\n\n const /** @type {?} */ prev = record._prev;\n const /** @type {?} */ next = record._next;\n\n // todo(vicb)\n // assert((record._prev = null) === null);\n // assert((record._next = null) === null);\n\n if (prev === null) {\n this._itHead = next;\n } else {\n prev._next = next;\n }\n if (next === null) {\n this._itTail = prev;\n } else {\n next._prev = prev;\n }\n\n return record;\n }\n/**\n * \\@internal\n * @param {?} record\n * @param {?} toIndex\n * @return {?}\n */\n_addToMoves(record: IterableChangeRecord_<V>, toIndex: number): IterableChangeRecord_<V> {\n // todo(vicb)\n // assert(record._nextMoved === null);\n\n if (record.previousIndex === toIndex) {\n return record;\n }\n\n if (this._movesTail === null) {\n // todo(vicb)\n // assert(_movesHead === null);\n this._movesTail = this._movesHead = record;\n } else {\n // todo(vicb)\n // assert(_movesTail._nextMoved === null);\n this._movesTail = this._movesTail._nextMoved = record;\n }\n\n return record;\n }\n/**\n * @param {?} record\n * @return {?}\n */\nprivate _addToRemovals(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {\n if (this._unlinkedRecords === null) {\n this._unlinkedRecords = new _DuplicateMap<V>();\n }\n this._unlinkedRecords.put(record);\n record.currentIndex = null;\n record._nextRemoved = null;\n\n if (this._removalsTail === null) {\n // todo(vicb)\n // assert(_removalsHead === null);\n this._removalsTail = this._removalsHead = record;\n record._prevRemoved = null;\n } else {\n // todo(vicb)\n // assert(_removalsTail._nextRemoved === null);\n // assert(record._nextRemoved === null);\n record._prevRemoved = this._removalsTail;\n this._removalsTail = this._removalsTail._nextRemoved = record;\n }\n return record;\n }\n/**\n * \\@internal\n * @param {?} record\n * @param {?} item\n * @return {?}\n */\n_addIdentityChange(record: IterableChangeRecord_<V>, item: V) {\n record.item = item;\n if (this._identityChangesTail === null) {\n this._identityChangesTail = this._identityChangesHead = record;\n } else {\n this._identityChangesTail = this._identityChangesTail._nextIdentityChange = record;\n }\n return record;\n }\n/**\n * @return {?}\n */\ntoString(): string {\n const /** @type {?} */ list: IterableChangeRecord_<V>[] = [];\n this.forEachItem((record: IterableChangeRecord_<V>) => list.push(record));\n\n const /** @type {?} */ previous: IterableChangeRecord_<V>[] = [];\n this.forEachPreviousItem((record: IterableChangeRecord_<V>) => previous.push(record));\n\n const /** @type {?} */ additions: IterableChangeRecord_<V>[] = [];\n this.forEachAddedItem((record: IterableChangeRecord_<V>) => additions.push(record));\n\n const /** @type {?} */ moves: IterableChangeRecord_<V>[] = [];\n this.forEachMovedItem((record: IterableChangeRecord_<V>) => moves.push(record));\n\n const /** @type {?} */ removals: IterableChangeRecord_<V>[] = [];\n this.forEachRemovedItem((record: IterableChangeRecord_<V>) => removals.push(record));\n\n const /** @type {?} */ identityChanges: IterableChangeRecord_<V>[] = [];\n this.forEachIdentityChange((record: IterableChangeRecord_<V>) => identityChanges.push(record));\n\n return 'collection: ' + list.join(', ') + '\\n' +\n 'previous: ' + previous.join(', ') + '\\n' +\n 'additions: ' + additions.join(', ') + '\\n' +\n 'moves: ' + moves.join(', ') + '\\n' +\n 'removals: ' + removals.join(', ') + '\\n' +\n 'identityChanges: ' + identityChanges.join(', ') + '\\n';\n }\n}\n\nfunction DefaultIterableDiffer_tsickle_Closure_declarations() {\n/** @type {?} */\nDefaultIterableDiffer.prototype._length;\n/** @type {?} */\nDefaultIterableDiffer.prototype._collection;\n/** @type {?} */\nDefaultIterableDiffer.prototype._linkedRecords;\n/** @type {?} */\nDefaultIterableDiffer.prototype._unlinkedRecords;\n/** @type {?} */\nDefaultIterableDiffer.prototype._previousItHead;\n/** @type {?} */\nDefaultIterableDiffer.prototype._itHead;\n/** @type {?} */\nDefaultIterableDiffer.prototype._itTail;\n/** @type {?} */\nDefaultIterableDiffer.prototype._additionsHead;\n/** @type {?} */\nDefaultIterableDiffer.prototype._additionsTail;\n/** @type {?} */\nDefaultIterableDiffer.prototype._movesHead;\n/** @type {?} */\nDefaultIterableDiffer.prototype._movesTail;\n/** @type {?} */\nDefaultIterableDiffer.prototype._removalsHead;\n/** @type {?} */\nDefaultIterableDiffer.prototype._removalsTail;\n/** @type {?} */\nDefaultIterableDiffer.prototype._identityChangesHead;\n/** @type {?} */\nDefaultIterableDiffer.prototype._identityChangesTail;\n/** @type {?} */\nDefaultIterableDiffer.prototype._trackByFn;\n}\n\n/**\n * \\@stable\n */\nexport class IterableChangeRecord_<V> implements IterableChangeRecord<V> {\n currentIndex: number|null = null;\n previousIndex: number|null = null;\n/**\n * \\@internal\n */\n_nextPrevious: IterableChangeRecord_<V>|null = null;\n/**\n * \\@internal\n */\n_prev: IterableChangeRecord_<V>|null = null;\n/**\n * \\@internal\n */\n_next: IterableChangeRecord_<V>|null = null;\n/**\n * \\@internal\n */\n_prevDup: IterableChangeRecord_<V>|null = null;\n/**\n * \\@internal\n */\n_nextDup: IterableChangeRecord_<V>|null = null;\n/**\n * \\@internal\n */\n_prevRemoved: IterableChangeRecord_<V>|null = null;\n/**\n * \\@internal\n */\n_nextRemoved: IterableChangeRecord_<V>|null = null;\n/**\n * \\@internal\n */\n_nextAdded: IterableChangeRecord_<V>|null = null;\n/**\n * \\@internal\n */\n_nextMoved: IterableChangeRecord_<V>|null = null;\n/**\n * \\@internal\n */\n_nextIdentityChange: IterableChangeRecord_<V>|null = null;\n/**\n * @param {?} item\n * @param {?} trackById\n */\nconstructor(public item: V,\npublic trackById: any) {}\n/**\n * @return {?}\n */\ntoString(): string {\n return this.previousIndex === this.currentIndex ? stringify(this.item) :\n stringify(this.item) + '[' +\n stringify(this.previousIndex) + '->' + stringify(this.currentIndex) + ']';\n }\n}\n\nfunction IterableChangeRecord__tsickle_Closure_declarations() {\n/** @type {?} */\nIterableChangeRecord_.prototype.currentIndex;\n/** @type {?} */\nIterableChangeRecord_.prototype.previousIndex;\n/**\n * \\@internal\n * @type {?}\n */\nIterableChangeRecord_.prototype._nextPrevious;\n/**\n * \\@internal\n * @type {?}\n */\nIterableChangeRecord_.prototype._prev;\n/**\n * \\@internal\n * @type {?}\n */\nIterableChangeRecord_.prototype._next;\n/**\n * \\@internal\n * @type {?}\n */\nIterableChangeRecord_.prototype._prevDup;\n/**\n * \\@internal\n * @type {?}\n */\nIterableChangeRecord_.prototype._nextDup;\n/**\n * \\@internal\n * @type {?}\n */\nIterableChangeRecord_.prototype._prevRemoved;\n/**\n * \\@internal\n * @type {?}\n */\nIterableChangeRecord_.prototype._nextRemoved;\n/**\n * \\@internal\n * @type {?}\n */\nIterableChangeRecord_.prototype._nextAdded;\n/**\n * \\@internal\n * @type {?}\n */\nIterableChangeRecord_.prototype._nextMoved;\n/**\n * \\@internal\n * @type {?}\n */\nIterableChangeRecord_.prototype._nextIdentityChange;\n/** @type {?} */\nIterableChangeRecord_.prototype.item;\n/** @type {?} */\nIterableChangeRecord_.prototype.trackById;\n}\n\nclass _DuplicateItemRecordList<V> {\n/**\n * \\@internal\n */\n_head: IterableChangeRecord_<V>|null = null;\n/**\n * \\@internal\n */\n_tail: IterableChangeRecord_<V>|null = null;\n/**\n * Append the record to the list of duplicates.\n * \n * Note: by design all records in the list of duplicates hold the same value in record.item.\n * @param {?} record\n * @return {?}\n */\nadd(record: IterableChangeRecord_<V>): void {\n if (this._head === null) {\n this._head = this._tail = record;\n record._nextDup = null;\n record._prevDup = null;\n } else { /** @type {?} */((\n // todo(vicb)\n // assert(record.item == _head.item ||\n // record.item is num && record.item.isNaN && _head.item is num && _head.item.isNaN);\n this._tail))._nextDup = record;\n record._prevDup = this._tail;\n record._nextDup = null;\n this._tail = record;\n }\n }\n/**\n * @param {?} trackById\n * @param {?} afterIndex\n * @return {?}\n */\nget(trackById: any, afterIndex: number|null): IterableChangeRecord_<V>|null {\n let /** @type {?} */ record: IterableChangeRecord_<V>|null;\n for (record = this._head; record !== null; record = record._nextDup) {\n if ((afterIndex === null || afterIndex < record.currentIndex) &&\n looseIdentical(record.trackById, trackById)) {\n return record;\n }\n }\n return null;\n }\n/**\n * Remove one {\\@link IterableChangeRecord_} from the list of duplicates.\n * \n * Returns whether the list of duplicates is empty.\n * @param {?} record\n * @return {?}\n */\nremove(record: IterableChangeRecord_<V>): boolean {\n // todo(vicb)\n // assert(() {\n // // verify that the record being removed is in the list.\n // for (IterableChangeRecord_ cursor = _head; cursor != null; cursor = cursor._nextDup) {\n // if (identical(cursor, record)) return true;\n // }\n // return false;\n //});\n\n const /** @type {?} */ prev: IterableChangeRecord_<V>|null = record._prevDup;\n const /** @type {?} */ next: IterableChangeRecord_<V>|null = record._nextDup;\n if (prev === null) {\n this._head = next;\n } else {\n prev._nextDup = next;\n }\n if (next === null) {\n this._tail = prev;\n } else {\n next._prevDup = prev;\n }\n return this._head === null;\n }\n}\n\nfunction _DuplicateItemRecordList_tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\n_DuplicateItemRecordList.prototype._head;\n/**\n * \\@internal\n * @type {?}\n */\n_DuplicateItemRecordList.prototype._tail;\n}\n\nclass _DuplicateMap<V> {\n map = new Map<any, _DuplicateItemRecordList<V>>();\n/**\n * @param {?} record\n * @return {?}\n */\nput(record: IterableChangeRecord_<V>) {\n const /** @type {?} */ key = record.trackById;\n\n let /** @type {?} */ duplicates = this.map.get(key);\n if (!duplicates) {\n duplicates = new _DuplicateItemRecordList<V>();\n this.map.set(key, duplicates);\n }\n duplicates.add(record);\n }\n/**\n * Retrieve the `value` using key. Because the IterableChangeRecord_ value may be one which we\n * have already iterated over, we use the afterIndex to pretend it is not there.\n * \n * Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we\n * have any more `a`s needs to return the last `a` not the first or second.\n * @param {?} trackById\n * @param {?} afterIndex\n * @return {?}\n */\nget(trackById: any, afterIndex: number|null): IterableChangeRecord_<V>|null {\n const /** @type {?} */ key = trackById;\n const /** @type {?} */ recordList = this.map.get(key);\n return recordList ? recordList.get(trackById, afterIndex) : null;\n }\n/**\n * Removes a {\\@link IterableChangeRecord_} from the list of duplicates.\n * \n * The list of duplicates also is removed from the map if it gets empty.\n * @param {?} record\n * @return {?}\n */\nremove(record: IterableChangeRecord_<V>): IterableChangeRecord_<V> {\n const /** @type {?} */ key = record.trackById;\n const /** @type {?} */ recordList: _DuplicateItemRecordList<V> = /** @type {?} */(( this.map.get(key)));\n // Remove the list of duplicates when it gets empty\n if (recordList.remove(record)) {\n this.map.delete(key);\n }\n return record;\n }\n/**\n * @return {?}\n */\nget isEmpty(): boolean { return this.map.size === 0; }\n/**\n * @return {?}\n */\nclear() { this.map.clear(); }\n/**\n * @return {?}\n */\ntoString(): string { return '_DuplicateMap(' + stringify(this.map) + ')'; }\n}\n\nfunction _DuplicateMap_tsickle_Closure_declarations() {\n/** @type {?} */\n_DuplicateMap.prototype.map;\n}\n\n/**\n * @param {?} item\n * @param {?} addRemoveOffset\n * @param {?} moveOffsets\n * @return {?}\n */\nfunction getPreviousIndex(\n item: any, addRemoveOffset: number, moveOffsets: number[] | null): number {\n const /** @type {?} */ previousIndex = item.previousIndex;\n if (previousIndex === null) return previousIndex;\n let /** @type {?} */ moveOffset = 0;\n if (moveOffsets && previousIndex < moveOffsets.length) {\n moveOffset = moveOffsets[previousIndex];\n }\n return previousIndex + addRemoveOffset + moveOffset;\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 {looseIdentical, stringify} from '../../util';\nimport {isJsObject} from '../change_detection_util';\nimport {ChangeDetectorRef} from '../change_detector_ref';\nimport {KeyValueChangeRecord, KeyValueChanges, KeyValueDiffer, KeyValueDifferFactory} from './keyvalue_differs';\nexport class DefaultKeyValueDifferFactory<K, V> implements KeyValueDifferFactory {\nconstructor() {}\n/**\n * @param {?} obj\n * @return {?}\n */\nsupports(obj: any): boolean { return obj instanceof Map || isJsObject(obj); }\n\n create<K, V>(): DefaultKeyValueDiffer<K, V>;\n/**\n * @deprecated v4.0.0 - ChangeDetectorRef is not used and is no longer a parameter\n * @template K, V\n * @param {?=} cd\n * @return {?}\n */\ncreate<K, V>(cd?: ChangeDetectorRef): KeyValueDiffer<K, V> {\n return new DefaultKeyValueDiffer<K, V>();\n }\n}\nexport class DefaultKeyValueDiffer<K, V> implements KeyValueDiffer<K, V>, KeyValueChanges<K, V> {\nprivate _records = new Map<K, KeyValueChangeRecord_<K, V>>();\nprivate _mapHead: KeyValueChangeRecord_<K, V>|null = null;\nprivate _appendAfter: KeyValueChangeRecord_<K, V>|null = null;\nprivate _previousMapHead: KeyValueChangeRecord_<K, V>|null = null;\nprivate _changesHead: KeyValueChangeRecord_<K, V>|null = null;\nprivate _changesTail: KeyValueChangeRecord_<K, V>|null = null;\nprivate _additionsHead: KeyValueChangeRecord_<K, V>|null = null;\nprivate _additionsTail: KeyValueChangeRecord_<K, V>|null = null;\nprivate _removalsHead: KeyValueChangeRecord_<K, V>|null = null;\nprivate _removalsTail: KeyValueChangeRecord_<K, V>|null = null;\n/**\n * @return {?}\n */\nget isDirty(): boolean {\n return this._additionsHead !== null || this._changesHead !== null ||\n this._removalsHead !== null;\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {\n let /** @type {?} */ record: KeyValueChangeRecord_<K, V>|null;\n for (record = this._mapHead; record !== null; record = record._next) {\n fn(record);\n }\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachPreviousItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {\n let /** @type {?} */ record: KeyValueChangeRecord_<K, V>|null;\n for (record = this._previousMapHead; record !== null; record = record._nextPrevious) {\n fn(record);\n }\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachChangedItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {\n let /** @type {?} */ record: KeyValueChangeRecord_<K, V>|null;\n for (record = this._changesHead; record !== null; record = record._nextChanged) {\n fn(record);\n }\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachAddedItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {\n let /** @type {?} */ record: KeyValueChangeRecord_<K, V>|null;\n for (record = this._additionsHead; record !== null; record = record._nextAdded) {\n fn(record);\n }\n }\n/**\n * @param {?} fn\n * @return {?}\n */\nforEachRemovedItem(fn: (r: KeyValueChangeRecord<K, V>) => void) {\n let /** @type {?} */ record: KeyValueChangeRecord_<K, V>|null;\n for (record = this._removalsHead; record !== null; record = record._nextRemoved) {\n fn(record);\n }\n }\n/**\n * @param {?=} map\n * @return {?}\n */\ndiff(map?: Map<any, any>|{[k: string]: any}|null): any {\n if (!map) {\n map = new Map();\n } else if (!(map instanceof Map || isJsObject(map))) {\n throw new Error(\n `Error trying to diff '${stringify(map)}'. Only maps and objects are allowed`);\n }\n\n return this.check(map) ? this : null;\n }\n/**\n * @return {?}\n */\nonDestroy() {}\n/**\n * Check the current state of the map vs the previous.\n * The algorithm is optimised for when the keys do no change.\n * @param {?} map\n * @return {?}\n */\ncheck(map: Map<any, any>|{[k: string]: any}): boolean {\n this._reset();\n\n let /** @type {?} */ insertBefore = this._mapHead;\n this._appendAfter = null;\n\n this._forEach(map, (value: any, key: any) => {\n if (insertBefore && insertBefore.key === key) {\n this._maybeAddToChanges(insertBefore, value);\n this._appendAfter = insertBefore;\n insertBefore = insertBefore._next;\n } else {\n const /** @type {?} */ record = this._getOrCreateRecordForKey(key, value);\n insertBefore = this._insertBeforeOrAppend(insertBefore, record);\n }\n });\n\n // Items remaining at the end of the list have been deleted\n if (insertBefore) {\n if (insertBefore._prev) {\n insertBefore._prev._next = null;\n }\n\n this._removalsHead = insertBefore;\n\n for (let /** @type {?} */ record: KeyValueChangeRecord_<K, V>|null = insertBefore; record !== null;\n record = record._nextRemoved) {\n if (record === this._mapHead) {\n this._mapHead = null;\n }\n this._records.delete(record.key);\n record._nextRemoved = record._next;\n record.previousValue = record.currentValue;\n record.currentValue = null;\n record._prev = null;\n record._next = null;\n }\n }\n\n // Make sure tails have no next records from previous runs\n if (this._changesTail) this._changesTail._nextChanged = null;\n if (this._additionsTail) this._additionsTail._nextAdded = null;\n\n return this.isDirty;\n }\n/**\n * Inserts a record before `before` or append at the end of the list when `before` is null.\n * \n * Notes:\n * - This method appends at `this._appendAfter`,\n * - This method updates `this._appendAfter`,\n * - The return value is the new value for the insertion pointer.\n * @param {?} before\n * @param {?} record\n * @return {?}\n */\nprivate _insertBeforeOrAppend(\n before: KeyValueChangeRecord_<K, V>|null,\n record: KeyValueChangeRecord_<K, V>): KeyValueChangeRecord_<K, V>|null {\n if (before) {\n const /** @type {?} */ prev = before._prev;\n record._next = before;\n record._prev = prev;\n before._prev = record;\n if (prev) {\n prev._next = record;\n }\n if (before === this._mapHead) {\n this._mapHead = record;\n }\n\n this._appendAfter = before;\n return before;\n }\n\n if (this._appendAfter) {\n this._appendAfter._next = record;\n record._prev = this._appendAfter;\n } else {\n this._mapHead = record;\n }\n\n this._appendAfter = record;\n return null;\n }\n/**\n * @param {?} key\n * @param {?} value\n * @return {?}\n */\nprivate _getOrCreateRecordForKey(key: K, value: V): KeyValueChangeRecord_<K, V> {\n if (this._records.has(key)) {\n const /** @type {?} */ record = /** @type {?} */(( this._records.get(key)));\n this._maybeAddToChanges(record, value);\n const /** @type {?} */ prev = record._prev;\n const /** @type {?} */ next = record._next;\n if (prev) {\n prev._next = next;\n }\n if (next) {\n next._prev = prev;\n }\n record._next = null;\n record._prev = null;\n\n return record;\n }\n\n const /** @type {?} */ record = new KeyValueChangeRecord_<K, V>(key);\n this._records.set(key, record);\n record.currentValue = value;\n this._addToAdditions(record);\n return record;\n }\n/**\n * \\@internal\n * @return {?}\n */\n_reset() {\n if (this.isDirty) {\n let /** @type {?} */ record: KeyValueChangeRecord_<K, V>|null;\n // let `_previousMapHead` contain the state of the map before the changes\n this._previousMapHead = this._mapHead;\n for (record = this._previousMapHead; record !== null; record = record._next) {\n record._nextPrevious = record._next;\n }\n\n // Update `record.previousValue` with the value of the item before the changes\n // We need to update all changed items (that's those which have been added and changed)\n for (record = this._changesHead; record !== null; record = record._nextChanged) {\n record.previousValue = record.currentValue;\n }\n for (record = this._additionsHead; record != null; record = record._nextAdded) {\n record.previousValue = record.currentValue;\n }\n\n this._changesHead = this._changesTail = null;\n this._additionsHead = this._additionsTail = null;\n this._removalsHead = null;\n }\n }\n/**\n * @param {?} record\n * @param {?} newValue\n * @return {?}\n */\nprivate _maybeAddToChanges(record: KeyValueChangeRecord_<K, V>, newValue: any): void {\n if (!looseIdentical(newValue, record.currentValue)) {\n record.previousValue = record.currentValue;\n record.currentValue = newValue;\n this._addToChanges(record);\n }\n }\n/**\n * @param {?} record\n * @return {?}\n */\nprivate _addToAdditions(record: KeyValueChangeRecord_<K, V>) {\n if (this._additionsHead === null) {\n this._additionsHead = this._additionsTail = record;\n } else { /** @type {?} */((\n this._additionsTail))._nextAdded = record;\n this._additionsTail = record;\n }\n }\n/**\n * @param {?} record\n * @return {?}\n */\nprivate _addToChanges(record: KeyValueChangeRecord_<K, V>) {\n if (this._changesHead === null) {\n this._changesHead = this._changesTail = record;\n } else { /** @type {?} */((\n this._changesTail))._nextChanged = record;\n this._changesTail = record;\n }\n }\n/**\n * @return {?}\n */\ntoString(): string {\n const /** @type {?} */ items: string[] = [];\n const /** @type {?} */ previous: string[] = [];\n const /** @type {?} */ changes: string[] = [];\n const /** @type {?} */ additions: string[] = [];\n const /** @type {?} */ removals: string[] = [];\n\n this.forEachItem(r => items.push(stringify(r)));\n this.forEachPreviousItem(r => previous.push(stringify(r)));\n this.forEachChangedItem(r => changes.push(stringify(r)));\n this.forEachAddedItem(r => additions.push(stringify(r)));\n this.forEachRemovedItem(r => removals.push(stringify(r)));\n\n return 'map: ' + items.join(', ') + '\\n' +\n 'previous: ' + previous.join(', ') + '\\n' +\n 'additions: ' + additions.join(', ') + '\\n' +\n 'changes: ' + changes.join(', ') + '\\n' +\n 'removals: ' + removals.join(', ') + '\\n';\n }\n/**\n * \\@internal\n * @template K, V\n * @param {?} obj\n * @param {?} fn\n * @return {?}\n */\nprivate _forEach<K, V>(obj: Map<K, V>|{[k: string]: V}, fn: (v: V, k: any) => void) {\n if (obj instanceof Map) {\n obj.forEach(fn);\n } else {\n Object.keys(obj).forEach(k => fn(obj[k], k));\n }\n }\n}\n\nfunction DefaultKeyValueDiffer_tsickle_Closure_declarations() {\n/** @type {?} */\nDefaultKeyValueDiffer.prototype._records;\n/** @type {?} */\nDefaultKeyValueDiffer.prototype._mapHead;\n/** @type {?} */\nDefaultKeyValueDiffer.prototype._appendAfter;\n/** @type {?} */\nDefaultKeyValueDiffer.prototype._previousMapHead;\n/** @type {?} */\nDefaultKeyValueDiffer.prototype._changesHead;\n/** @type {?} */\nDefaultKeyValueDiffer.prototype._changesTail;\n/** @type {?} */\nDefaultKeyValueDiffer.prototype._additionsHead;\n/** @type {?} */\nDefaultKeyValueDiffer.prototype._additionsTail;\n/** @type {?} */\nDefaultKeyValueDiffer.prototype._removalsHead;\n/** @type {?} */\nDefaultKeyValueDiffer.prototype._removalsTail;\n}\n\n/**\n * \\@stable\n */\nclass KeyValueChangeRecord_<K, V> implements KeyValueChangeRecord<K, V> {\n previousValue: V|null = null;\n currentValue: V|null = null;\n/**\n * \\@internal\n */\n_nextPrevious: KeyValueChangeRecord_<K, V>|null = null;\n/**\n * \\@internal\n */\n_next: KeyValueChangeRecord_<K, V>|null = null;\n/**\n * \\@internal\n */\n_prev: KeyValueChangeRecord_<K, V>|null = null;\n/**\n * \\@internal\n */\n_nextAdded: KeyValueChangeRecord_<K, V>|null = null;\n/**\n * \\@internal\n */\n_nextRemoved: KeyValueChangeRecord_<K, V>|null = null;\n/**\n * \\@internal\n */\n_nextChanged: KeyValueChangeRecord_<K, V>|null = null;\n/**\n * @param {?} key\n */\nconstructor(public key: K) {}\n/**\n * @return {?}\n */\ntoString(): string {\n return looseIdentical(this.previousValue, this.currentValue) ?\n stringify(this.key) :\n (stringify(this.key) + '[' + stringify(this.previousValue) + '->' +\n stringify(this.currentValue) + ']');\n }\n}\n\nfunction KeyValueChangeRecord__tsickle_Closure_declarations() {\n/** @type {?} */\nKeyValueChangeRecord_.prototype.previousValue;\n/** @type {?} */\nKeyValueChangeRecord_.prototype.currentValue;\n/**\n * \\@internal\n * @type {?}\n */\nKeyValueChangeRecord_.prototype._nextPrevious;\n/**\n * \\@internal\n * @type {?}\n */\nKeyValueChangeRecord_.prototype._next;\n/**\n * \\@internal\n * @type {?}\n */\nKeyValueChangeRecord_.prototype._prev;\n/**\n * \\@internal\n * @type {?}\n */\nKeyValueChangeRecord_.prototype._nextAdded;\n/**\n * \\@internal\n * @type {?}\n */\nKeyValueChangeRecord_.prototype._nextRemoved;\n/**\n * \\@internal\n * @type {?}\n */\nKeyValueChangeRecord_.prototype._nextChanged;\n/** @type {?} */\nKeyValueChangeRecord_.prototype.key;\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 {Optional, Provider, SkipSelf} from '../../di';\nimport {ChangeDetectorRef} from '../change_detector_ref';\n\n/**\n * A type describing supported interable types.\n *\n * @stable\n */\nexport type NgIterable<T> = Array<T>| Iterable<T>;\n\n/**\n * A strategy for tracking changes over time to an iterable. Used by {@link NgFor} to\n * respond to changes in an iterable by effecting equivalent changes in the DOM.\n *\n * @stable\n */\nexport interface IterableDiffer<V> {\n /**\n * Compute a difference between the previous state and the new `object` state.\n *\n * @param object containing the new value.\n * @returns an object describing the difference. The return value is only valid until the next\n * `diff()` invocation.\n */\n diff(object: NgIterable<V>): IterableChanges<V>|null;\n}\n\n/**\n * An object describing the changes in the `Iterable` collection since last time\n * `IterableDiffer#diff()` was invoked.\n *\n * @stable\n */\nexport interface IterableChanges<V> {\n /**\n * Iterate over all changes. `IterableChangeRecord` will contain information about changes\n * to each item.\n */\n forEachItem(fn: (record: IterableChangeRecord<V>) => void): void;\n\n /**\n * Iterate over a set of operations which when applied to the original `Iterable` will produce the\n * new `Iterable`.\n *\n * NOTE: These are not necessarily the actual operations which were applied to the original\n * `Iterable`, rather these are a set of computed operations which may not be the same as the\n * ones applied.\n *\n * @param record A change which needs to be applied\n * @param previousIndex The `IterableChangeRecord#previousIndex` of the `record` refers to the\n * original `Iterable` location, where as `previousIndex` refers to the transient location\n * of the item, after applying the operations up to this point.\n * @param currentIndex The `IterableChangeRecord#currentIndex` of the `record` refers to the\n * original `Iterable` location, where as `currentIndex` refers to the transient location\n * of the item, after applying the operations up to this point.\n */\n forEachOperation(\n fn: (record: IterableChangeRecord<V>, previousIndex: number, currentIndex: number) => void):\n void;\n\n /**\n * Iterate over changes in the order of original `Iterable` showing where the original items\n * have moved.\n */\n forEachPreviousItem(fn: (record: IterableChangeRecord<V>) => void): void;\n\n /** Iterate over all added items. */\n forEachAddedItem(fn: (record: IterableChangeRecord<V>) => void): void;\n\n /** Iterate over all moved items. */\n forEachMovedItem(fn: (record: IterableChangeRecord<V>) => void): void;\n\n /** Iterate over all removed items. */\n forEachRemovedItem(fn: (record: IterableChangeRecord<V>) => void): void;\n\n /** Iterate over all items which had their identity (as computed by the `trackByFn`) changed. */\n forEachIdentityChange(fn: (record: IterableChangeRecord<V>) => void): void;\n}\n\n/**\n * Record representing the item change information.\n *\n * @stable\n */\nexport interface IterableChangeRecord<V> {\n /** Current index of the item in `Iterable` or null if removed. */\n readonly currentIndex: number|null;\n\n /** Previous index of the item in `Iterable` or null if added. */\n readonly previousIndex: number|null;\n\n /** The item. */\n readonly item: V;\n\n /** Track by identity as computed by the `trackByFn`. */\n readonly trackById: any;\n}\n\n/**\n * @deprecated v4.0.0 - Use IterableChangeRecord instead.\n */\nexport interface CollectionChangeRecord<V> extends IterableChangeRecord<V> {}\n\n\n/**\n * Nolonger used.\n *\n * @deprecated v4.0.0 - Use TrackByFunction instead\n */\nexport interface TrackByFn { (index: number, item: any): any; }\n\n/**\n * An optional function passed into {@link NgForOf} that defines how to track\n * items in an iterable (e.g. fby index or id)\n *\n * @stable\n */\nexport interface TrackByFunction<T> { (index: number, item: T): any; }\n\n/**\n * Provides a factory for {@link IterableDiffer}.\n *\n * @stable\n */\nexport interface IterableDifferFactory {\n supports(objects: any): boolean;\n create<V>(trackByFn?: TrackByFunction<V>): IterableDiffer<V>;\n\n /**\n * @deprecated v4.0.0 - ChangeDetectorRef is not used and is no longer a parameter\n */\n create<V>(_cdr?: ChangeDetectorRef|TrackByFunction<V>, trackByFn?: TrackByFunction<V>):\n IterableDiffer<V>;\n}\n/**\n * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.\n * \\@stable\n */\nexport class IterableDiffers {\n/**\n * @deprecated v4.0.0 - Should be private\n */\nfactories: IterableDifferFactory[];\n/**\n * @param {?} factories\n */\nconstructor(factories: IterableDifferFactory[]) { this.factories = factories; }\n/**\n * @param {?} factories\n * @param {?=} parent\n * @return {?}\n */\nstatic create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers {\n if (parent != null) {\n const /** @type {?} */ copied = parent.factories.slice();\n factories = factories.concat(copied);\n return new IterableDiffers(factories);\n } else {\n return new IterableDiffers(factories);\n }\n }\n/**\n * Takes an array of {\\@link IterableDifferFactory} and returns a provider used to extend the\n * inherited {\\@link IterableDiffers} instance with the provided factories and return a new\n * {\\@link IterableDiffers} instance.\n * \n * The following example shows how to extend an existing list of factories,\n * which will only be applied to the injector for this component and its children.\n * This step is all that's required to make a new {\\@link IterableDiffer} available.\n * \n * ### Example\n * \n * ```\n * \\@Component({ \n * viewProviders: [\n * IterableDiffers.extend([new ImmutableListDiffer()])\n * ]\n * })\n * ```\n * @param {?} factories\n * @return {?}\n */\nstatic extend(factories: IterableDifferFactory[]): Provider {\n return {\n provide: IterableDiffers,\n useFactory: (parent: IterableDiffers) => {\n if (!parent) {\n // Typically would occur when calling IterableDiffers.extend inside of dependencies passed\n // to\n // bootstrap(), which would override default pipes instead of extending them.\n throw new Error('Cannot extend IterableDiffers without a parent injector');\n }\n return IterableDiffers.create(factories, parent);\n },\n // Dependency technically isn't optional, but we can provide a better error message this way.\n deps: [[IterableDiffers, new SkipSelf(), new Optional()]]\n };\n }\n/**\n * @param {?} iterable\n * @return {?}\n */\nfind(iterable: any): IterableDifferFactory {\n const /** @type {?} */ factory = this.factories.find(f => f.supports(iterable));\n if (factory != null) {\n return factory;\n } else {\n throw new Error(\n `Cannot find a differ supporting object '${iterable}' of type '${getTypeNameForDebugging(iterable)}'`);\n }\n }\n}\n\nfunction IterableDiffers_tsickle_Closure_declarations() {\n/**\n * @deprecated v4.0.0 - Should be private\n * @type {?}\n */\nIterableDiffers.prototype.factories;\n}\n\n/**\n * @param {?} type\n * @return {?}\n */\nexport function getTypeNameForDebugging(type: any): string {\n return type['name'] || typeof type;\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 {Optional, Provider, SkipSelf} from '../../di';\nimport {ChangeDetectorRef} from '../change_detector_ref';\n\n\n\n/**\n * A differ that tracks changes made to an object over time.\n *\n * @stable\n */\nexport interface KeyValueDiffer<K, V> {\n /**\n * Compute a difference between the previous state and the new `object` state.\n *\n * @param object containing the new value.\n * @returns an object describing the difference. The return value is only valid until the next\n * `diff()` invocation.\n */\n diff(object: Map<K, V>): KeyValueChanges<K, V>;\n\n /**\n * Compute a difference between the previous state and the new `object` state.\n *\n * @param object containing the new value.\n * @returns an object describing the difference. The return value is only valid until the next\n * `diff()` invocation.\n */\n diff(object: {[key: string]: V}): KeyValueChanges<string, V>;\n // TODO(TS2.1): diff<KP extends string>(this: KeyValueDiffer<KP, V>, object: Record<KP, V>):\n // KeyValueDiffer<KP, V>;\n}\n\n/**\n * An object describing the changes in the `Map` or `{[k:string]: string}` since last time\n * `KeyValueDiffer#diff()` was invoked.\n *\n * @stable\n */\nexport interface KeyValueChanges<K, V> {\n /**\n * Iterate over all changes. `KeyValueChangeRecord` will contain information about changes\n * to each item.\n */\n forEachItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;\n\n /**\n * Iterate over changes in the order of original Map showing where the original items\n * have moved.\n */\n forEachPreviousItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;\n\n /**\n * Iterate over all keys for which values have changed.\n */\n forEachChangedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;\n\n /**\n * Iterate over all added items.\n */\n forEachAddedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;\n\n /**\n * Iterate over all removed items.\n */\n forEachRemovedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;\n}\n\n/**\n * Record representing the item change information.\n *\n * @stable\n */\nexport interface KeyValueChangeRecord<K, V> {\n /**\n * Current key in the Map.\n */\n readonly key: K;\n\n /**\n * Current value for the key or `null` if removed.\n */\n readonly currentValue: V|null;\n\n /**\n * Previous value for the key or `null` if added.\n */\n readonly previousValue: V|null;\n}\n\n/**\n * Provides a factory for {@link KeyValueDiffer}.\n *\n * @stable\n */\nexport interface KeyValueDifferFactory {\n /**\n * Test to see if the differ knows how to diff this kind of object.\n */\n supports(objects: any): boolean;\n\n /**\n * Create a `KeyValueDiffer`.\n */\n create<K, V>(): KeyValueDiffer<K, V>;\n\n /**\n * @deprecated v4.0.0 - ChangeDetectorRef is not used and is no longer a parameter\n */\n create<K, V>(_cdr?: ChangeDetectorRef): KeyValueDiffer<K, V>;\n}\n/**\n * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.\n * \\@stable\n */\nexport class KeyValueDiffers {\n/**\n * @deprecated v4.0.0 - Should be private.\n */\nfactories: KeyValueDifferFactory[];\n/**\n * @param {?} factories\n */\nconstructor(factories: KeyValueDifferFactory[]) { this.factories = factories; }\n/**\n * @template S\n * @param {?} factories\n * @param {?=} parent\n * @return {?}\n */\nstatic create<S>(factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers {\n if (parent) {\n const /** @type {?} */ copied = parent.factories.slice();\n factories = factories.concat(copied);\n }\n return new KeyValueDiffers(factories);\n }\n/**\n * Takes an array of {\\@link KeyValueDifferFactory} and returns a provider used to extend the\n * inherited {\\@link KeyValueDiffers} instance with the provided factories and return a new\n * {\\@link KeyValueDiffers} instance.\n * \n * The following example shows how to extend an existing list of factories,\n * which will only be applied to the injector for this component and its children.\n * This step is all that's required to make a new {\\@link KeyValueDiffer} available.\n * \n * ### Example\n * \n * ```\n * \\@Component({ \n * viewProviders: [\n * KeyValueDiffers.extend([new ImmutableMapDiffer()])\n * ]\n * })\n * ```\n * @template S\n * @param {?} factories\n * @return {?}\n */\nstatic extend<S>(factories: KeyValueDifferFactory[]): Provider {\n return {\n provide: KeyValueDiffers,\n useFactory: (parent: KeyValueDiffers) => {\n if (!parent) {\n // Typically would occur when calling KeyValueDiffers.extend inside of dependencies passed\n // to bootstrap(), which would override default pipes instead of extending them.\n throw new Error('Cannot extend KeyValueDiffers without a parent injector');\n }\n return KeyValueDiffers.create(factories, parent);\n },\n // Dependency technically isn't optional, but we can provide a better error message this way.\n deps: [[KeyValueDiffers, new SkipSelf(), new Optional()]]\n };\n }\n/**\n * @param {?} kv\n * @return {?}\n */\nfind(kv: any): KeyValueDifferFactory {\n const /** @type {?} */ factory = this.factories.find(f => f.supports(kv));\n if (factory) {\n return factory;\n }\n throw new Error(`Cannot find a differ supporting object '${kv}'`);\n }\n}\n\nfunction KeyValueDiffers_tsickle_Closure_declarations() {\n/**\n * @deprecated v4.0.0 - Should be private.\n * @type {?}\n */\nKeyValueDiffers.prototype.factories;\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 {InjectionToken} from '../di/injection_token';\n/**\n * \\@experimental i18n support is experimental.\n */\nexport const LOCALE_ID = new InjectionToken<string>('LocaleId');\n/**\n * \\@experimental i18n support is experimental.\n */\nexport const TRANSLATIONS = new InjectionToken<string>('Translations');\n/**\n * \\@experimental i18n support is experimental.\n */\nexport const TRANSLATIONS_FORMAT = new InjectionToken<string>('TranslationsFormat');\nexport type MissingTranslationStrategy = number;\nexport let MissingTranslationStrategy: any = {};\nMissingTranslationStrategy.Error = 0;\nMissingTranslationStrategy.Warning = 1;\nMissingTranslationStrategy.Ignore = 2;\nMissingTranslationStrategy[MissingTranslationStrategy.Error] = \"Error\";\nMissingTranslationStrategy[MissingTranslationStrategy.Warning] = \"Warning\";\nMissingTranslationStrategy[MissingTranslationStrategy.Ignore] = \"Ignore\";\n\n","\nexport type SecurityContext = number;\nexport let SecurityContext: any = {};\nSecurityContext.NONE = 0;\nSecurityContext.HTML = 1;\nSecurityContext.STYLE = 2;\nSecurityContext.SCRIPT = 3;\nSecurityContext.URL = 4;\nSecurityContext.RESOURCE_URL = 5;\nSecurityContext[SecurityContext.NONE] = \"NONE\";\nSecurityContext[SecurityContext.HTML] = \"HTML\";\nSecurityContext[SecurityContext.STYLE] = \"STYLE\";\nSecurityContext[SecurityContext.SCRIPT] = \"SCRIPT\";\nSecurityContext[SecurityContext.URL] = \"URL\";\nSecurityContext[SecurityContext.RESOURCE_URL] = \"RESOURCE_URL\";\n\n/**\n * Sanitizer is used by the views to sanitize potentially dangerous values.\n * \n * \\@stable\n * @abstract\n */\nexport abstract class Sanitizer {\n/**\n * @abstract\n * @param {?} context\n * @param {?} value\n * @return {?}\n */\nsanitize(context: SecurityContext, value: {}|string|null) {}\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} from '../di';\nimport {ErrorHandler} from '../error_handler';\nimport {NgModuleRef} from '../linker/ng_module_factory';\nimport {QueryList} from '../linker/query_list';\nimport {TemplateRef} from '../linker/template_ref';\nimport {ViewContainerRef} from '../linker/view_container_ref';\nimport {Renderer2, RendererFactory2, RendererType2} from '../render/api';\nimport {Sanitizer, SecurityContext} from '../security';\n\n// -------------------------------------\n// Defs\n// -------------------------------------\n\nexport interface ViewDefinition {\n factory: ViewDefinitionFactory|null;\n flags: ViewFlags;\n updateDirectives: ViewUpdateFn;\n updateRenderer: ViewUpdateFn;\n handleEvent: ViewHandleEventFn;\n /**\n * Order: Depth first.\n * Especially providers are before elements / anchors.\n */\n nodes: NodeDef[];\n /** aggregated NodeFlags for all nodes **/\n nodeFlags: NodeFlags;\n rootNodeFlags: NodeFlags;\n lastRenderRootNode: NodeDef|null;\n bindingCount: number;\n outputCount: number;\n /**\n * Binary or of all query ids that are matched by one of the nodes.\n * This includes query ids from templates as well.\n * Used as a bloom filter.\n */\n nodeMatchedQueries: number;\n}\n\n/**\n * Factory for ViewDefinitions.\n * We use a function so we can reexeute it in case an error happens and use the given logger\n * function to log the error from the definition of the node, which is shown in all browser\n * logs.\n */\nexport interface ViewDefinitionFactory { (logger: NodeLogger): ViewDefinition; }\n\n/**\n * Function to call console.error at the right source location. This is an indirection\n * via another function as browser will log the location that actually called\n * `console.error`.\n */\nexport interface NodeLogger { (): () => void; }\n\nexport interface ViewUpdateFn { (check: NodeCheckFn, view: ViewData): void; }\n\n// helper functions to create an overloaded function type.\nexport interface NodeCheckFn {\n (view: ViewData, nodeIndex: number, argStyle: ArgumentType.Dynamic, values: any[]): any;\n\n (view: ViewData, nodeIndex: number, argStyle: ArgumentType.Inline, v0?: any, v1?: any, v2?: any,\n v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): any;\n}\n\nexport const enum ArgumentType {Inline, Dynamic}\n\nexport interface ViewHandleEventFn {\n (view: ViewData, nodeIndex: number, eventName: string, event: any): boolean;\n}\n\n/**\n * Bitmask for ViewDefintion.flags.\n */\nexport const enum ViewFlags {\n None = 0,\n OnPush = 1 << 1,\n}\n\n/**\n * A node definition in the view.\n *\n * Note: We use one type for all nodes so that loops that loop over all nodes\n * of a ViewDefinition stay monomorphic!\n */\nexport interface NodeDef {\n flags: NodeFlags;\n index: number;\n parent: NodeDef|null;\n renderParent: NodeDef|null;\n /** this is checked against NgContentDef.index to find matched nodes */\n ngContentIndex: number;\n /** number of transitive children */\n childCount: number;\n /** aggregated NodeFlags for all transitive children (does not include self) **/\n childFlags: NodeFlags;\n /** aggregated NodeFlags for all direct children (does not include self) **/\n directChildFlags: NodeFlags;\n\n bindingIndex: number;\n bindings: BindingDef[];\n bindingFlags: BindingFlags;\n outputIndex: number;\n outputs: OutputDef[];\n /**\n * references that the user placed on the element\n */\n references: {[refId: string]: QueryValueType};\n /**\n * ids and value types of all queries that are matched by this node.\n */\n matchedQueries: {[queryId: number]: QueryValueType};\n /** Binary or of all matched query ids of this node. */\n matchedQueryIds: number;\n /**\n * Binary or of all query ids that are matched by one of the children.\n * This includes query ids from templates as well.\n * Used as a bloom filter.\n */\n childMatchedQueries: number;\n element: ElementDef|null;\n provider: ProviderDef|null;\n text: TextDef|null;\n query: QueryDef|null;\n ngContent: NgContentDef|null;\n}\n\n/**\n * Bitmask for NodeDef.flags.\n * Naming convention:\n * - `Type...`: flags that are mutually exclusive\n * - `Cat...`: union of multiple `Type...` (short for category).\n */\nexport const enum NodeFlags {\n None = 0,\n TypeElement = 1 << 0,\n TypeText = 1 << 1,\n CatRenderNode = TypeElement | TypeText,\n TypeNgContent = 1 << 2,\n TypePipe = 1 << 3,\n TypePureArray = 1 << 4,\n TypePureObject = 1 << 5,\n TypePurePipe = 1 << 6,\n CatPureExpression = TypePureArray | TypePureObject | TypePurePipe,\n TypeValueProvider = 1 << 7,\n TypeClassProvider = 1 << 8,\n TypeFactoryProvider = 1 << 9,\n TypeUseExistingProvider = 1 << 10,\n LazyProvider = 1 << 11,\n PrivateProvider = 1 << 12,\n TypeDirective = 1 << 13,\n Component = 1 << 14,\n CatProvider = TypeValueProvider | TypeClassProvider | TypeFactoryProvider |\n TypeUseExistingProvider | TypeDirective,\n OnInit = 1 << 15,\n OnDestroy = 1 << 16,\n DoCheck = 1 << 17,\n OnChanges = 1 << 18,\n AfterContentInit = 1 << 19,\n AfterContentChecked = 1 << 20,\n AfterViewInit = 1 << 21,\n AfterViewChecked = 1 << 22,\n EmbeddedViews = 1 << 23,\n ComponentView = 1 << 24,\n TypeContentQuery = 1 << 25,\n TypeViewQuery = 1 << 26,\n StaticQuery = 1 << 27,\n DynamicQuery = 1 << 28,\n CatQuery = TypeContentQuery | TypeViewQuery,\n\n // mutually exclusive values...\n Types = CatRenderNode | TypeNgContent | TypePipe | CatPureExpression | CatProvider | CatQuery\n}\n\nexport interface BindingDef {\n flags: BindingFlags;\n ns: string|null;\n name: string|null;\n nonMinifiedName: string|null;\n securityContext: SecurityContext|null;\n suffix: string|null;\n}\n\nexport const enum BindingFlags {\n TypeElementAttribute = 1 << 0,\n TypeElementClass = 1 << 1,\n TypeElementStyle = 1 << 2,\n TypeProperty = 1 << 3,\n SyntheticProperty = 1 << 4,\n SyntheticHostProperty = 1 << 5,\n CatSyntheticProperty = SyntheticProperty | SyntheticHostProperty,\n\n // mutually exclusive values...\n Types = TypeElementAttribute | TypeElementClass | TypeElementStyle | TypeProperty\n}\n\nexport interface OutputDef {\n type: OutputType;\n target: 'window'|'document'|'body'|'component'|null;\n eventName: string;\n propName: string|null;\n}\n\nexport const enum OutputType {ElementOutput, DirectiveOutput}\n\nexport const enum QueryValueType {\n ElementRef,\n RenderElement,\n TemplateRef,\n ViewContainerRef,\n Provider\n}\n\nexport interface ElementDef {\n name: string|null;\n ns: string|null;\n /** ns, name, value */\n attrs: [string, string, string][]|null;\n template: ViewDefinition|null;\n componentProvider: NodeDef|null;\n componentRendererType: RendererType2|null;\n // closure to allow recursive components\n componentView: ViewDefinitionFactory|null;\n /**\n * visible public providers for DI in the view,\n * as see from this element. This does not include private providers.\n */\n publicProviders: {[tokenKey: string]: NodeDef}|null;\n /**\n * same as visiblePublicProviders, but also includes private providers\n * that are located on this element.\n */\n allProviders: {[tokenKey: string]: NodeDef}|null;\n handleEvent: ElementHandleEventFn|null;\n}\n\nexport interface ElementHandleEventFn { (view: ViewData, eventName: string, event: any): boolean; }\n\nexport interface ProviderDef {\n token: any;\n tokenKey: string;\n value: any;\n deps: DepDef[];\n}\n\nexport interface DepDef {\n flags: DepFlags;\n token: any;\n tokenKey: string;\n}\n\n/**\n * Bitmask for DI flags\n */\nexport const enum DepFlags {\n None = 0,\n SkipSelf = 1 << 0,\n Optional = 1 << 1,\n Value = 2 << 2,\n}\n\nexport interface TextDef { prefix: string; }\n\nexport interface QueryDef {\n id: number;\n // variant of the id that can be used to check against NodeDef.matchedQueryIds, ...\n filterId: number;\n bindings: QueryBindingDef[];\n}\n\nexport interface QueryBindingDef {\n propName: string;\n bindingType: QueryBindingType;\n}\n\nexport const enum QueryBindingType {First, All}\n\nexport interface NgContentDef {\n /**\n * this index is checked against NodeDef.ngContentIndex to find the nodes\n * that are matched by this ng-content.\n * Note that a NodeDef with an ng-content can be reprojected, i.e.\n * have a ngContentIndex on its own.\n */\n index: number;\n}\n\n// -------------------------------------\n// Data\n// -------------------------------------\n\n/**\n * View instance data.\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface ViewData {\n def: ViewDefinition;\n root: RootData;\n renderer: Renderer2;\n // index of component provider / anchor.\n parentNodeDef: NodeDef|null;\n parent: ViewData|null;\n viewContainerParent: ViewData|null;\n component: any;\n context: any;\n // Attention: Never loop over this, as this will\n // create a polymorphic usage site.\n // Instead: Always loop over ViewDefinition.nodes,\n // and call the right accessor (e.g. `elementData`) based on\n // the NodeType.\n nodes: {[key: number]: NodeData};\n state: ViewState;\n oldValues: any[];\n disposables: DisposableFn[]|null;\n}\n\n/**\n * Bitmask of states\n */\nexport const enum ViewState {\n BeforeFirstCheck = 1 << 0,\n FirstCheck = 1 << 1,\n Attached = 1 << 2,\n ChecksEnabled = 1 << 3,\n Destroyed = 1 << 4,\n\n CatDetectChanges = Attached | ChecksEnabled,\n CatInit = BeforeFirstCheck | CatDetectChanges\n}\n\nexport interface DisposableFn { (): void; }\n/**\n * Node instance data.\n * \n * We have a separate type per NodeType to save memory\n * (TextData | ElementData | ProviderData | PureExpressionData | QueryList<any>)\n * \n * To keep our code monomorphic,\n * we prohibit using `NodeData` directly but enforce the use of accessors (`asElementData`, ...).\n * This way, no usage site can get a `NodeData` from view.nodes and then use it for different\n * purposes.\n */\nexport class NodeData {\nprivate __brand: any; }\n\nfunction NodeData_tsickle_Closure_declarations() {\n/** @type {?} */\nNodeData.prototype.__brand;\n}\n\n\n/**\n * Data for an instantiated NodeType.Text.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface TextData { renderText: any; }\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n * @param {?} view\n * @param {?} index\n * @return {?}\n */\nexport function asTextData(view: ViewData, index: number): TextData {\n return /** @type {?} */(( <any>view.nodes[index]));\n}\n\n/**\n * Data for an instantiated NodeType.Element.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface ElementData {\n renderElement: any;\n componentView: ViewData;\n viewContainer: ViewContainerData|null;\n template: TemplateData;\n}\n\nexport interface ViewContainerData extends ViewContainerRef { _embeddedViews: ViewData[]; }\n\nexport interface TemplateData extends TemplateRef<any> {\n // views that have been created from the template\n // of this element,\n // but inserted into the embeddedViews of another element.\n // By default, this is undefined.\n _projectedViews: ViewData[];\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n * @param {?} view\n * @param {?} index\n * @return {?}\n */\nexport function asElementData(view: ViewData, index: number): ElementData {\n return /** @type {?} */(( <any>view.nodes[index]));\n}\n\n/**\n * Data for an instantiated NodeType.Provider.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface ProviderData { instance: any; }\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n * @param {?} view\n * @param {?} index\n * @return {?}\n */\nexport function asProviderData(view: ViewData, index: number): ProviderData {\n return /** @type {?} */(( <any>view.nodes[index]));\n}\n\n/**\n * Data for an instantiated NodeType.PureExpression.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface PureExpressionData { value: any; }\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n * @param {?} view\n * @param {?} index\n * @return {?}\n */\nexport function asPureExpressionData(view: ViewData, index: number): PureExpressionData {\n return /** @type {?} */(( <any>view.nodes[index]));\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n * @param {?} view\n * @param {?} index\n * @return {?}\n */\nexport function asQueryList(view: ViewData, index: number): QueryList<any> {\n return /** @type {?} */(( <any>view.nodes[index]));\n}\n\nexport interface RootData {\n injector: Injector;\n ngModule: NgModuleRef<any>;\n projectableNodes: any[][];\n selectorOrNode: any;\n renderer: Renderer2;\n rendererFactory: RendererFactory2;\n errorHandler: ErrorHandler;\n sanitizer: Sanitizer;\n}\n/**\n * @abstract\n */\nexport abstract class DebugContext {\n/**\n * @abstract\n * @return {?}\n */\nview() {}\n/**\n * @abstract\n * @return {?}\n */\nnodeIndex() {}\n/**\n * @abstract\n * @return {?}\n */\ninjector() {}\n/**\n * @abstract\n * @return {?}\n */\ncomponent() {}\n/**\n * @abstract\n * @return {?}\n */\nproviderTokens() {}\n/**\n * @abstract\n * @return {?}\n */\nreferences() {}\n/**\n * @abstract\n * @return {?}\n */\ncontext() {}\n/**\n * @abstract\n * @return {?}\n */\ncomponentRenderElement() {}\n/**\n * @abstract\n * @return {?}\n */\nrenderNode() {}\n/**\n * @abstract\n * @param {?} console\n * @param {...?} values\n * @return {?}\n */\nlogError(console: Console, ...values: any[]) {}\n}\n\n// -------------------------------------\n// Other\n// -------------------------------------\n\nexport const enum CheckType {CheckAndUpdate, CheckNoChanges}\n\nexport interface Services {\n setCurrentNode(view: ViewData, nodeIndex: number): void;\n createRootView(\n injector: Injector, projectableNodes: any[][], rootSelectorOrNode: string|any,\n def: ViewDefinition, ngModule: NgModuleRef<any>, context?: any): ViewData;\n createEmbeddedView(parent: ViewData, anchorDef: NodeDef, context?: any): ViewData;\n checkAndUpdateView(view: ViewData): void;\n checkNoChangesView(view: ViewData): void;\n destroyView(view: ViewData): void;\n resolveDep(\n view: ViewData, elDef: NodeDef|null, allowPrivateServices: boolean, depDef: DepDef,\n notFoundValue?: any): any;\n createDebugContext(view: ViewData, nodeIndex: number): DebugContext;\n handleEvent: ViewHandleEventFn;\n updateDirectives: (view: ViewData, checkType: CheckType) => void;\n updateRenderer: (view: ViewData, checkType: CheckType) => void;\n dirtyParentQueries: (view: ViewData) => void;\n}\n\n/**\n * This object is used to prevent cycles in the source files and to have a place where\n * debug mode can hook it. It is lazily filled when `isDevMode` is known.\n */\nexport const /** @type {?} */ Services: Services = {\n setCurrentNode: /** @type {?} */(( undefined)),\n createRootView: /** @type {?} */(( undefined)),\n createEmbeddedView: /** @type {?} */(( undefined)),\n checkAndUpdateView: /** @type {?} */(( undefined)),\n checkNoChangesView: /** @type {?} */(( undefined)),\n destroyView: /** @type {?} */(( undefined)),\n resolveDep: /** @type {?} */(( undefined)),\n createDebugContext: /** @type {?} */(( undefined)),\n handleEvent: /** @type {?} */(( undefined)),\n updateDirectives: /** @type {?} */(( undefined)),\n updateRenderer: /** @type {?} */(( undefined)),\n dirtyParentQueries: /** @type {?} */(( undefined)),\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 {ERROR_DEBUG_CONTEXT, ERROR_LOGGER, getDebugContext} from '../errors';\nimport {DebugContext, ViewState} from './types';\n/**\n * @param {?} context\n * @param {?} oldValue\n * @param {?} currValue\n * @param {?} isFirstCheck\n * @return {?}\n */\nexport function expressionChangedAfterItHasBeenCheckedError(\n context: DebugContext, oldValue: any, currValue: any, isFirstCheck: boolean): Error {\n let /** @type {?} */ msg =\n `ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value: '${oldValue}'. Current value: '${currValue}'.`;\n if (isFirstCheck) {\n msg +=\n ` It seems like the view has been created after its parent and its children have been dirty checked.` +\n ` Has it been created in a change detection hook ?`;\n }\n return viewDebugError(msg, context);\n}\n/**\n * @param {?} err\n * @param {?} context\n * @return {?}\n */\nexport function viewWrappedDebugError(err: any, context: DebugContext): Error {\n if (!(err instanceof Error)) {\n // errors that are not Error instances don't have a stack,\n // so it is ok to wrap them into a new Error object...\n err = new Error(err.toString());\n }\n _addDebugContext(err, context);\n return err;\n}\n/**\n * @param {?} msg\n * @param {?} context\n * @return {?}\n */\nexport function viewDebugError(msg: string, context: DebugContext): Error {\n const /** @type {?} */ err = new Error(msg);\n _addDebugContext(err, context);\n return err;\n}\n/**\n * @param {?} err\n * @param {?} context\n * @return {?}\n */\nfunction _addDebugContext(err: Error, context: DebugContext) {\n ( /** @type {?} */((err as any)))[ERROR_DEBUG_CONTEXT] = context;\n ( /** @type {?} */((err as any)))[ERROR_LOGGER] = context.logError.bind(context);\n}\n/**\n * @param {?} err\n * @return {?}\n */\nexport function isViewDebugError(err: Error): boolean {\n return !!getDebugContext(err);\n}\n/**\n * @param {?} action\n * @return {?}\n */\nexport function viewDestroyedError(action: string): Error {\n return new Error(`ViewDestroyedError: Attempt to use a destroyed view: ${action}`);\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 {WrappedValue, devModeEqual} from '../change_detection/change_detection';\nimport {ViewEncapsulation} from '../metadata/view';\nimport {RendererType2} from '../render/api';\nimport {looseIdentical, stringify} from '../util';\n\nimport {expressionChangedAfterItHasBeenCheckedError} from './errors';\nimport {BindingDef, BindingFlags, ElementData, NodeDef, NodeFlags, QueryValueType, Services, ViewData, ViewDefinition, ViewDefinitionFactory, ViewFlags, ViewState, asElementData, asTextData} from './types';\n\nexport const /** @type {?} */ NOOP: any = () => {};\n\nconst /** @type {?} */ _tokenKeyCache = new Map<any, string>();\n/**\n * @param {?} token\n * @return {?}\n */\nexport function tokenKey(token: any): string {\n let /** @type {?} */ key = _tokenKeyCache.get(token);\n if (!key) {\n key = stringify(token) + '_' + _tokenKeyCache.size;\n _tokenKeyCache.set(token, key);\n }\n return key;\n}\n/**\n * @param {?} view\n * @param {?} nodeIdx\n * @param {?} bindingIdx\n * @param {?} value\n * @return {?}\n */\nexport function unwrapValue(view: ViewData, nodeIdx: number, bindingIdx: number, value: any): any {\n if (value instanceof WrappedValue) {\n value = value.wrapped;\n let /** @type {?} */ globalBindingIdx = view.def.nodes[nodeIdx].bindingIndex + bindingIdx;\n let /** @type {?} */ oldValue = view.oldValues[globalBindingIdx];\n if (oldValue instanceof WrappedValue) {\n oldValue = oldValue.wrapped;\n }\n view.oldValues[globalBindingIdx] = new WrappedValue(oldValue);\n }\n return value;\n}\n\nconst /** @type {?} */ UNDEFINED_RENDERER_TYPE_ID = '$$undefined';\nconst /** @type {?} */ EMPTY_RENDERER_TYPE_ID = '$$empty';\n/**\n * @param {?} values\n * @return {?}\n */\nexport function createRendererType2(values: {\n styles: (string | any[])[],\n encapsulation: ViewEncapsulation,\n data: {[kind: string]: any[]}\n}): RendererType2 {\n return {\n id: UNDEFINED_RENDERER_TYPE_ID,\n styles: values.styles,\n encapsulation: values.encapsulation,\n data: values.data\n };\n}\n\nlet /** @type {?} */ _renderCompCount = 0;\n/**\n * @param {?=} type\n * @return {?}\n */\nexport function resolveRendererType2(type?: RendererType2 | null): RendererType2|null {\n if (type && type.id === UNDEFINED_RENDERER_TYPE_ID) {\n // first time we see this RendererType2. Initialize it...\n const /** @type {?} */ isFilled =\n ((type.encapsulation != null && type.encapsulation !== ViewEncapsulation.None) ||\n type.styles.length || Object.keys(type.data).length);\n if (isFilled) {\n type.id = `c${_renderCompCount++}`;\n } else {\n type.id = EMPTY_RENDERER_TYPE_ID;\n }\n }\n if (type && type.id === EMPTY_RENDERER_TYPE_ID) {\n type = null;\n }\n return type || null;\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} bindingIdx\n * @param {?} value\n * @return {?}\n */\nexport function checkBinding(\n view: ViewData, def: NodeDef, bindingIdx: number, value: any): boolean {\n const /** @type {?} */ oldValues = view.oldValues;\n if ((view.state & ViewState.FirstCheck) ||\n !looseIdentical(oldValues[def.bindingIndex + bindingIdx], value)) {\n return true;\n }\n return false;\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} bindingIdx\n * @param {?} value\n * @return {?}\n */\nexport function checkAndUpdateBinding(\n view: ViewData, def: NodeDef, bindingIdx: number, value: any): boolean {\n if (checkBinding(view, def, bindingIdx, value)) {\n view.oldValues[def.bindingIndex + bindingIdx] = value;\n return true;\n }\n return false;\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} bindingIdx\n * @param {?} value\n * @return {?}\n */\nexport function checkBindingNoChanges(\n view: ViewData, def: NodeDef, bindingIdx: number, value: any) {\n const /** @type {?} */ oldValue = view.oldValues[def.bindingIndex + bindingIdx];\n if ((view.state & ViewState.BeforeFirstCheck) || !devModeEqual(oldValue, value)) {\n throw expressionChangedAfterItHasBeenCheckedError(\n Services.createDebugContext(view, def.index), oldValue, value,\n (view.state & ViewState.BeforeFirstCheck) !== 0);\n }\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function markParentViewsForCheck(view: ViewData) {\n let /** @type {?} */ currView: ViewData|null = view;\n while (currView) {\n if (currView.def.flags & ViewFlags.OnPush) {\n currView.state |= ViewState.ChecksEnabled;\n }\n currView = currView.viewContainerParent || currView.parent;\n }\n}\n/**\n * @param {?} view\n * @param {?} nodeIndex\n * @param {?} eventName\n * @param {?} event\n * @return {?}\n */\nexport function dispatchEvent(\n view: ViewData, nodeIndex: number, eventName: string, event: any): boolean {\n const /** @type {?} */ nodeDef = view.def.nodes[nodeIndex];\n const /** @type {?} */ startView =\n nodeDef.flags & NodeFlags.ComponentView ? asElementData(view, nodeIndex).componentView : view;\n markParentViewsForCheck(startView);\n return Services.handleEvent(view, nodeIndex, eventName, event);\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function declaredViewContainer(view: ViewData): ElementData|null {\n if (view.parent) {\n const /** @type {?} */ parentView = view.parent;\n return asElementData(parentView, /** @type {?} */(( view.parentNodeDef)).index);\n }\n return null;\n}\n/**\n * for component views, this is the host element.\n * for embedded views, this is the index of the parent node\n * that contains the view container.\n * @param {?} view\n * @return {?}\n */\nexport function viewParentEl(view: ViewData): NodeDef|null {\n const /** @type {?} */ parentView = view.parent;\n if (parentView) {\n return /** @type {?} */(( view.parentNodeDef)).parent;\n } else {\n return null;\n }\n}\n/**\n * @param {?} view\n * @param {?} def\n * @return {?}\n */\nexport function renderNode(view: ViewData, def: NodeDef): any {\n switch (def.flags & NodeFlags.Types) {\n case NodeFlags.TypeElement:\n return asElementData(view, def.index).renderElement;\n case NodeFlags.TypeText:\n return asTextData(view, def.index).renderText;\n }\n}\n/**\n * @param {?} target\n * @param {?} name\n * @return {?}\n */\nexport function elementEventFullName(target: string | null, name: string): string {\n return target ? `${target}:${name}` : name;\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function isComponentView(view: ViewData): boolean {\n return !!view.parent && !!( /** @type {?} */((view.parentNodeDef)).flags & NodeFlags.Component);\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function isEmbeddedView(view: ViewData): boolean {\n return !!view.parent && !( /** @type {?} */((view.parentNodeDef)).flags & NodeFlags.Component);\n}\n/**\n * @param {?} queryId\n * @return {?}\n */\nexport function filterQueryId(queryId: number): number {\n return 1 << (queryId % 32);\n}\n/**\n * @param {?} matchedQueriesDsl\n * @return {?}\n */\nexport function splitMatchedQueriesDsl(\n matchedQueriesDsl: [string | number, QueryValueType][] | null): {\n matchedQueries: {[queryId: string]: QueryValueType},\n references: {[refId: string]: QueryValueType},\n matchedQueryIds: number\n} {\n const /** @type {?} */ matchedQueries: {[queryId: string]: QueryValueType} = {};\n let /** @type {?} */ matchedQueryIds = 0;\n const /** @type {?} */ references: {[refId: string]: QueryValueType} = {};\n if (matchedQueriesDsl) {\n matchedQueriesDsl.forEach(([queryId, valueType]) => {\n if (typeof queryId === 'number') {\n matchedQueries[queryId] = valueType;\n matchedQueryIds |= filterQueryId(queryId);\n } else {\n references[queryId] = valueType;\n }\n });\n }\n return {matchedQueries, references, matchedQueryIds};\n}\n/**\n * @param {?} view\n * @param {?} renderHost\n * @param {?} def\n * @return {?}\n */\nexport function getParentRenderElement(view: ViewData, renderHost: any, def: NodeDef): any {\n let /** @type {?} */ renderParent = def.renderParent;\n if (renderParent) {\n if ((renderParent.flags & NodeFlags.TypeElement) === 0 ||\n (renderParent.flags & NodeFlags.ComponentView) === 0 ||\n ( /** @type {?} */((renderParent.element)).componentRendererType && /** @type {?} */(( /** @type {?} */((\n renderParent.element)).componentRendererType)).encapsulation ===\n ViewEncapsulation.Native)) {\n // only children of non components, or children of components with native encapsulation should\n // be attached.\n return asElementData(view, /** @type {?} */(( def.renderParent)).index).renderElement;\n }\n } else {\n return renderHost;\n }\n}\n\nconst /** @type {?} */ VIEW_DEFINITION_CACHE = new WeakMap<any, ViewDefinition>();\n/**\n * @param {?} factory\n * @return {?}\n */\nexport function resolveViewDefinition(factory: ViewDefinitionFactory): ViewDefinition {\n let /** @type {?} */ value: ViewDefinition = /** @type {?} */(( VIEW_DEFINITION_CACHE.get(factory)));\n if (!value) {\n value = factory(() => NOOP);\n value.factory = factory;\n VIEW_DEFINITION_CACHE.set(factory, value);\n }\n return value;\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function rootRenderNodes(view: ViewData): any[] {\n const /** @type {?} */ renderNodes: any[] = [];\n visitRootRenderNodes(view, RenderNodeAction.Collect, undefined, undefined, renderNodes);\n return renderNodes;\n}\n\nexport const enum RenderNodeAction {Collect, AppendChild, InsertBefore, RemoveChild}\n/**\n * @param {?} view\n * @param {?} action\n * @param {?} parentNode\n * @param {?} nextSibling\n * @param {?=} target\n * @return {?}\n */\nexport function visitRootRenderNodes(\n view: ViewData, action: RenderNodeAction, parentNode: any, nextSibling: any, target?: any[]) {\n // We need to re-compute the parent node in case the nodes have been moved around manually\n if (action === RenderNodeAction.RemoveChild) {\n parentNode = view.renderer.parentNode(renderNode(view, /** @type {?} */(( view.def.lastRenderRootNode))));\n }\n visitSiblingRenderNodes(\n view, action, 0, view.def.nodes.length - 1, parentNode, nextSibling, target);\n}\n/**\n * @param {?} view\n * @param {?} action\n * @param {?} startIndex\n * @param {?} endIndex\n * @param {?} parentNode\n * @param {?} nextSibling\n * @param {?=} target\n * @return {?}\n */\nexport function visitSiblingRenderNodes(\n view: ViewData, action: RenderNodeAction, startIndex: number, endIndex: number, parentNode: any,\n nextSibling: any, target?: any[]) {\n for (let /** @type {?} */ i = startIndex; i <= endIndex; i++) {\n const /** @type {?} */ nodeDef = view.def.nodes[i];\n if (nodeDef.flags & (NodeFlags.TypeElement | NodeFlags.TypeText | NodeFlags.TypeNgContent)) {\n visitRenderNode(view, nodeDef, action, parentNode, nextSibling, target);\n }\n // jump to next sibling\n i += nodeDef.childCount;\n }\n}\n/**\n * @param {?} view\n * @param {?} ngContentIndex\n * @param {?} action\n * @param {?} parentNode\n * @param {?} nextSibling\n * @param {?=} target\n * @return {?}\n */\nexport function visitProjectedRenderNodes(\n view: ViewData, ngContentIndex: number, action: RenderNodeAction, parentNode: any,\n nextSibling: any, target?: any[]) {\n let /** @type {?} */ compView: ViewData|null = view;\n while (compView && !isComponentView(compView)) {\n compView = compView.parent;\n }\n const /** @type {?} */ hostView = /** @type {?} */(( compView)).parent;\n const /** @type {?} */ hostElDef = viewParentEl( /** @type {?} */((compView)));\n const /** @type {?} */ startIndex = /** @type {?} */(( hostElDef)).index + 1;\n const /** @type {?} */ endIndex = /** @type {?} */(( hostElDef)).index + /** @type {?} */(( hostElDef)).childCount;\n for (let /** @type {?} */ i = startIndex; i <= endIndex; i++) {\n const /** @type {?} */ nodeDef = /** @type {?} */(( hostView)).def.nodes[i];\n if (nodeDef.ngContentIndex === ngContentIndex) {\n visitRenderNode( /** @type {?} */((hostView)), nodeDef, action, parentNode, nextSibling, target);\n }\n // jump to next sibling\n i += nodeDef.childCount;\n }\n if (! /** @type {?} */((hostView)).parent) {\n // a root view\n const /** @type {?} */ projectedNodes = view.root.projectableNodes[ngContentIndex];\n if (projectedNodes) {\n for (let /** @type {?} */ i = 0; i < projectedNodes.length; i++) {\n execRenderNodeAction(view, projectedNodes[i], action, parentNode, nextSibling, target);\n }\n }\n }\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @param {?} action\n * @param {?} parentNode\n * @param {?} nextSibling\n * @param {?=} target\n * @return {?}\n */\nfunction visitRenderNode(\n view: ViewData, nodeDef: NodeDef, action: RenderNodeAction, parentNode: any, nextSibling: any,\n target?: any[]) {\n if (nodeDef.flags & NodeFlags.TypeNgContent) {\n visitProjectedRenderNodes(\n view, /** @type {?} */(( nodeDef.ngContent)).index, action, parentNode, nextSibling, target);\n } else {\n const /** @type {?} */ rn = renderNode(view, nodeDef);\n if (action === RenderNodeAction.RemoveChild && (nodeDef.flags & NodeFlags.ComponentView) &&\n (nodeDef.bindingFlags & BindingFlags.CatSyntheticProperty)) {\n // Note: we might need to do both actions.\n if (nodeDef.bindingFlags & (BindingFlags.SyntheticProperty)) {\n execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);\n }\n if (nodeDef.bindingFlags & (BindingFlags.SyntheticHostProperty)) {\n const /** @type {?} */ compView = asElementData(view, nodeDef.index).componentView;\n execRenderNodeAction(compView, rn, action, parentNode, nextSibling, target);\n }\n } else {\n execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);\n }\n if (nodeDef.flags & NodeFlags.EmbeddedViews) {\n const /** @type {?} */ embeddedViews = /** @type {?} */(( asElementData(view, nodeDef.index).viewContainer))._embeddedViews;\n for (let /** @type {?} */ k = 0; k < embeddedViews.length; k++) {\n visitRootRenderNodes(embeddedViews[k], action, parentNode, nextSibling, target);\n }\n }\n if (nodeDef.flags & NodeFlags.TypeElement && ! /** @type {?} */((nodeDef.element)).name) {\n visitSiblingRenderNodes(\n view, action, nodeDef.index + 1, nodeDef.index + nodeDef.childCount, parentNode,\n nextSibling, target);\n }\n }\n}\n/**\n * @param {?} view\n * @param {?} renderNode\n * @param {?} action\n * @param {?} parentNode\n * @param {?} nextSibling\n * @param {?=} target\n * @return {?}\n */\nfunction execRenderNodeAction(\n view: ViewData, renderNode: any, action: RenderNodeAction, parentNode: any, nextSibling: any,\n target?: any[]) {\n const /** @type {?} */ renderer = view.renderer;\n switch (action) {\n case RenderNodeAction.AppendChild:\n renderer.appendChild(parentNode, renderNode);\n break;\n case RenderNodeAction.InsertBefore:\n renderer.insertBefore(parentNode, renderNode, nextSibling);\n break;\n case RenderNodeAction.RemoveChild:\n renderer.removeChild(parentNode, renderNode);\n break;\n case RenderNodeAction.Collect: /** @type {?} */((\n target)).push(renderNode);\n break;\n }\n}\n\nconst /** @type {?} */ NS_PREFIX_RE = /^:([^:]+):(.+)$/;\n/**\n * @param {?} name\n * @return {?}\n */\nexport function splitNamespace(name: string): string[] {\n if (name[0] === ':') {\n const /** @type {?} */ match = /** @type {?} */(( name.match(NS_PREFIX_RE)));\n return [match[1], match[2]];\n }\n return ['', name];\n}\n/**\n * @param {?} bindings\n * @return {?}\n */\nexport function calcBindingFlags(bindings: BindingDef[]): BindingFlags {\n let /** @type {?} */ flags = 0;\n for (let /** @type {?} */ i = 0; i < bindings.length; i++) {\n flags |= bindings[i].flags;\n }\n return flags;\n}\n/**\n * @param {?} valueCount\n * @param {?} constAndInterp\n * @return {?}\n */\nexport function interpolate(valueCount: number, constAndInterp: string[]): string {\n let /** @type {?} */ result = '';\n for (let /** @type {?} */ i = 0; i < valueCount * 2; i = i + 2) {\n result = result + constAndInterp[i] + _toStringWithNull(constAndInterp[i + 1]);\n }\n return result + constAndInterp[valueCount * 2];\n}\n/**\n * @param {?} valueCount\n * @param {?} c0\n * @param {?} a1\n * @param {?} c1\n * @param {?=} a2\n * @param {?=} c2\n * @param {?=} a3\n * @param {?=} c3\n * @param {?=} a4\n * @param {?=} c4\n * @param {?=} a5\n * @param {?=} c5\n * @param {?=} a6\n * @param {?=} c6\n * @param {?=} a7\n * @param {?=} c7\n * @param {?=} a8\n * @param {?=} c8\n * @param {?=} a9\n * @param {?=} c9\n * @return {?}\n */\nexport function inlineInterpolate(\n valueCount: number, c0: string, a1: any, c1: string, a2?: any, c2?: string, a3?: any,\n c3?: string, a4?: any, c4?: string, a5?: any, c5?: string, a6?: any, c6?: string, a7?: any,\n c7?: string, a8?: any, c8?: string, a9?: any, c9?: string): string {\n switch (valueCount) {\n case 1:\n return c0 + _toStringWithNull(a1) + c1;\n case 2:\n return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2;\n case 3:\n return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n c3;\n case 4:\n return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n c3 + _toStringWithNull(a4) + c4;\n case 5:\n return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5;\n case 6:\n return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) + c6;\n case 7:\n return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +\n c6 + _toStringWithNull(a7) + c7;\n case 8:\n return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +\n c6 + _toStringWithNull(a7) + c7 + _toStringWithNull(a8) + c8;\n case 9:\n return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +\n c6 + _toStringWithNull(a7) + c7 + _toStringWithNull(a8) + c8 + _toStringWithNull(a9) + c9;\n default:\n throw new Error(`Does not support more than 9 expressions`);\n }\n}\n/**\n * @param {?} v\n * @return {?}\n */\nfunction _toStringWithNull(v: any): string {\n return v != null ? v.toString() : '';\n}\n\nexport const /** @type {?} */ EMPTY_ARRAY: any[] = [];\nexport const /** @type {?} */ EMPTY_MAP: {[key: string]: any} = {};\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 {InjectionToken, Injector} from '../di';\nimport {ViewEncapsulation} from '../metadata/view';\n/**\n * @deprecated Use `RendererType2` (and `Renderer2`) instead.\n */\nexport class RenderComponentType {\n/**\n * @param {?} id\n * @param {?} templateUrl\n * @param {?} slotCount\n * @param {?} encapsulation\n * @param {?} styles\n * @param {?} animations\n */\nconstructor(\npublic id: string,\npublic templateUrl: string,\npublic slotCount: number,\npublic encapsulation: ViewEncapsulation,\npublic styles: Array<string|any[]>,\npublic animations: any) {}\n}\n\nfunction RenderComponentType_tsickle_Closure_declarations() {\n/** @type {?} */\nRenderComponentType.prototype.id;\n/** @type {?} */\nRenderComponentType.prototype.templateUrl;\n/** @type {?} */\nRenderComponentType.prototype.slotCount;\n/** @type {?} */\nRenderComponentType.prototype.encapsulation;\n/** @type {?} */\nRenderComponentType.prototype.styles;\n/** @type {?} */\nRenderComponentType.prototype.animations;\n}\n\n/**\n * @deprecated Debug info is handeled internally in the view engine now.\n * @abstract\n */\nexport abstract class RenderDebugInfo {\n/**\n * @abstract\n * @return {?}\n */\ninjector() {}\n/**\n * @abstract\n * @return {?}\n */\ncomponent() {}\n/**\n * @abstract\n * @return {?}\n */\nproviderTokens() {}\n/**\n * @abstract\n * @return {?}\n */\nreferences() {}\n/**\n * @abstract\n * @return {?}\n */\ncontext() {}\n/**\n * @abstract\n * @return {?}\n */\nsource() {}\n}\n\n/**\n * @deprecated Use the `Renderer2` instead.\n */\nexport interface DirectRenderer {\n remove(node: any): void;\n appendChild(node: any, parent: any): void;\n insertBefore(node: any, refNode: any): void;\n nextSibling(node: any): any;\n parentElement(node: any): any;\n}\n/**\n * @deprecated Use the `Renderer2` instead.\n * @abstract\n */\nexport abstract class Renderer {\n/**\n * @abstract\n * @param {?} selectorOrNode\n * @param {?=} debugInfo\n * @return {?}\n */\nselectRootElement(selectorOrNode: string|any, debugInfo?: RenderDebugInfo) {}\n/**\n * @abstract\n * @param {?} parentElement\n * @param {?} name\n * @param {?=} debugInfo\n * @return {?}\n */\ncreateElement(parentElement: any, name: string, debugInfo?: RenderDebugInfo) {}\n/**\n * @abstract\n * @param {?} hostElement\n * @return {?}\n */\ncreateViewRoot(hostElement: any) {}\n/**\n * @abstract\n * @param {?} parentElement\n * @param {?=} debugInfo\n * @return {?}\n */\ncreateTemplateAnchor(parentElement: any, debugInfo?: RenderDebugInfo) {}\n/**\n * @abstract\n * @param {?} parentElement\n * @param {?} value\n * @param {?=} debugInfo\n * @return {?}\n */\ncreateText(parentElement: any, value: string, debugInfo?: RenderDebugInfo) {}\n/**\n * @abstract\n * @param {?} parentElement\n * @param {?} nodes\n * @return {?}\n */\nprojectNodes(parentElement: any, nodes: any[]) {}\n/**\n * @abstract\n * @param {?} node\n * @param {?} viewRootNodes\n * @return {?}\n */\nattachViewAfter(node: any, viewRootNodes: any[]) {}\n/**\n * @abstract\n * @param {?} viewRootNodes\n * @return {?}\n */\ndetachView(viewRootNodes: any[]) {}\n/**\n * @abstract\n * @param {?} hostElement\n * @param {?} viewAllNodes\n * @return {?}\n */\ndestroyView(hostElement: any, viewAllNodes: any[]) {}\n/**\n * @abstract\n * @param {?} renderElement\n * @param {?} name\n * @param {?} callback\n * @return {?}\n */\nlisten(renderElement: any, name: string, callback: Function) {}\n/**\n * @abstract\n * @param {?} target\n * @param {?} name\n * @param {?} callback\n * @return {?}\n */\nlistenGlobal(target: string, name: string, callback: Function) {}\n/**\n * @abstract\n * @param {?} renderElement\n * @param {?} propertyName\n * @param {?} propertyValue\n * @return {?}\n */\nsetElementProperty(renderElement: any, propertyName: string, propertyValue: any) {}\n/**\n * @abstract\n * @param {?} renderElement\n * @param {?} attributeName\n * @param {?} attributeValue\n * @return {?}\n */\nsetElementAttribute(renderElement: any, attributeName: string, attributeValue: string) {}\n/**\n * Used only in debug mode to serialize property changes to dom nodes as attributes.\n * @abstract\n * @param {?} renderElement\n * @param {?} propertyName\n * @param {?} propertyValue\n * @return {?}\n */\nsetBindingDebugInfo(renderElement: any, propertyName: string, propertyValue: string) {}\n/**\n * @abstract\n * @param {?} renderElement\n * @param {?} className\n * @param {?} isAdd\n * @return {?}\n */\nsetElementClass(renderElement: any, className: string, isAdd: boolean) {}\n/**\n * @abstract\n * @param {?} renderElement\n * @param {?} styleName\n * @param {?} styleValue\n * @return {?}\n */\nsetElementStyle(renderElement: any, styleName: string, styleValue: string) {}\n/**\n * @abstract\n * @param {?} renderElement\n * @param {?} methodName\n * @param {?=} args\n * @return {?}\n */\ninvokeElementMethod(renderElement: any, methodName: string, args?: any[]) {}\n/**\n * @abstract\n * @param {?} renderNode\n * @param {?} text\n * @return {?}\n */\nsetText(renderNode: any, text: string) {}\n/**\n * @abstract\n * @param {?} element\n * @param {?} startingStyles\n * @param {?} keyframes\n * @param {?} duration\n * @param {?} delay\n * @param {?} easing\n * @param {?=} previousPlayers\n * @return {?}\n */\nanimate(\n element: any, startingStyles: any, keyframes: any[], duration: number, delay: number,\n easing: string, previousPlayers?: any[]) {}\n}\n\nexport const /** @type {?} */ Renderer2Interceptor = new InjectionToken<Renderer2[]>('Renderer2Interceptor');\n/**\n * Injectable service that provides a low-level interface for modifying the UI.\n * \n * Use this service to bypass Angular's templating and make custom UI changes that can't be\n * expressed declaratively. For example if you need to set a property or an attribute whose name is\n * not statically known, use {\\@link #setElementProperty} or {\\@link #setElementAttribute}\n * respectively.\n * \n * If you are implementing a custom renderer, you must implement this interface.\n * \n * The default Renderer implementation is `DomRenderer`. Also available is `WebWorkerRenderer`.\n * \n * @deprecated Use `RendererFactory2` instead.\n * @abstract\n */\nexport abstract class RootRenderer {\n/**\n * @abstract\n * @param {?} componentType\n * @return {?}\n */\nrenderComponent(componentType: RenderComponentType) {}\n}\n\n/**\n * @experimental\n */\nexport interface RendererType2 {\n id: string;\n encapsulation: ViewEncapsulation;\n styles: (string|any[])[];\n data: {[kind: string]: any};\n}\n/**\n * \\@experimental\n * @abstract\n */\nexport abstract class RendererFactory2 {\n/**\n * @abstract\n * @param {?} hostElement\n * @param {?} type\n * @return {?}\n */\ncreateRenderer(hostElement: any, type: RendererType2|null) {}\n}\nexport type RendererStyleFlags2 = number;\nexport let RendererStyleFlags2: any = {};\nRendererStyleFlags2.Important = 1;\nRendererStyleFlags2.DashCase = 2;\nRendererStyleFlags2[RendererStyleFlags2.Important] = \"Important\";\nRendererStyleFlags2[RendererStyleFlags2.DashCase] = \"DashCase\";\n\n/**\n * \\@experimental\n * @abstract\n */\nexport abstract class Renderer2 {\n/**\n * This field can be used to store arbitrary data on this renderer instance.\n * This is useful for renderers that delegate to other renderers.\n * @abstract\n * @return {?}\n */\ndata() {}\n/**\n * @abstract\n * @return {?}\n */\ndestroy() {}\n/**\n * @abstract\n * @param {?} name\n * @param {?=} namespace\n * @return {?}\n */\ncreateElement(name: string, namespace?: string|null) {}\n/**\n * @abstract\n * @param {?} value\n * @return {?}\n */\ncreateComment(value: string) {}\n/**\n * @abstract\n * @param {?} value\n * @return {?}\n */\ncreateText(value: string) {}\n /**\n * This property is allowed to be null / undefined,\n * in which case the view engine won't call it.\n * This is used as a performance optimization for production mode.\n */\n destroyNode: ((node: any) => void)|null;\n/**\n * @abstract\n * @param {?} parent\n * @param {?} newChild\n * @return {?}\n */\nappendChild(parent: any, newChild: any) {}\n/**\n * @abstract\n * @param {?} parent\n * @param {?} newChild\n * @param {?} refChild\n * @return {?}\n */\ninsertBefore(parent: any, newChild: any, refChild: any) {}\n/**\n * @abstract\n * @param {?} parent\n * @param {?} oldChild\n * @return {?}\n */\nremoveChild(parent: any, oldChild: any) {}\n/**\n * @abstract\n * @param {?} selectorOrNode\n * @return {?}\n */\nselectRootElement(selectorOrNode: string|any) {}\n/**\n * Attention: On WebWorkers, this will always return a value,\n * as we are asking for a result synchronously. I.e.\n * the caller can't rely on checking whether this is null or not.\n * @abstract\n * @param {?} node\n * @return {?}\n */\nparentNode(node: any) {}\n/**\n * Attention: On WebWorkers, this will always return a value,\n * as we are asking for a result synchronously. I.e.\n * the caller can't rely on checking whether this is null or not.\n * @abstract\n * @param {?} node\n * @return {?}\n */\nnextSibling(node: any) {}\n/**\n * @abstract\n * @param {?} el\n * @param {?} name\n * @param {?} value\n * @param {?=} namespace\n * @return {?}\n */\nsetAttribute(el: any, name: string, value: string, namespace?: string|null) {}\n/**\n * @abstract\n * @param {?} el\n * @param {?} name\n * @param {?=} namespace\n * @return {?}\n */\nremoveAttribute(el: any, name: string, namespace?: string|null) {}\n/**\n * @abstract\n * @param {?} el\n * @param {?} name\n * @return {?}\n */\naddClass(el: any, name: string) {}\n/**\n * @abstract\n * @param {?} el\n * @param {?} name\n * @return {?}\n */\nremoveClass(el: any, name: string) {}\n/**\n * @abstract\n * @param {?} el\n * @param {?} style\n * @param {?} value\n * @param {?=} flags\n * @return {?}\n */\nsetStyle(el: any, style: string, value: any, flags?: RendererStyleFlags2) {}\n/**\n * @abstract\n * @param {?} el\n * @param {?} style\n * @param {?=} flags\n * @return {?}\n */\nremoveStyle(el: any, style: string, flags?: RendererStyleFlags2) {}\n/**\n * @abstract\n * @param {?} el\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\nsetProperty(el: any, name: string, value: any) {}\n/**\n * @abstract\n * @param {?} node\n * @param {?} value\n * @return {?}\n */\nsetValue(node: any, value: string) {}\n/**\n * @abstract\n * @param {?} target\n * @param {?} eventName\n * @param {?} callback\n * @return {?}\n */\nlisten(\n target: 'window'|'document'|'body'|any, eventName: string,\n callback: (event: any) => boolean | void) {}\n}\n\nfunction Renderer2_tsickle_Closure_declarations() {\n/**\n * This property is allowed to be null / undefined,\n * in which case the view engine won't call it.\n * This is used as a performance optimization for production mode.\n * @type {?}\n */\nRenderer2.prototype.destroyNode;\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 {Observable} from 'rxjs/Observable';\n\nimport {EventEmitter} from '../event_emitter';\nimport {getSymbolIterator} from '../util';\n/**\n * An unmodifiable list of items that Angular keeps up to date when the state\n * of the application changes.\n * \n * The type of object that {\\@link ViewChildren}, {\\@link ContentChildren}, and {\\@link QueryList}\n * provide.\n * \n * Implements an iterable interface, therefore it can be used in both ES6\n * javascript `for (var i of items)` loops as well as in Angular templates with\n * `*ngFor=\"let i of myList\"`.\n * \n * Changes can be observed by subscribing to the changes `Observable`.\n * \n * NOTE: In the future this class will implement an `Observable` interface.\n * \n * ### Example ([live demo](http://plnkr.co/edit/RX8sJnQYl9FWuSCWme5z?p=preview))\n * ```typescript\n * \\@Component({...}) \n * class Container {\n * \\@ViewChildren(Item) items:QueryList<Item>;\n * }\n * ```\n * \\@stable\n */\nexport class QueryList<T>/* implements Iterable<T> */ {\nprivate _dirty = true;\nprivate _results: Array<T> = [];\nprivate _emitter = new EventEmitter();\n/**\n * @return {?}\n */\nget changes(): Observable<any> { return this._emitter; }\n/**\n * @return {?}\n */\nget length(): number { return this._results.length; }\n/**\n * @return {?}\n */\nget first(): T { return this._results[0]; }\n/**\n * @return {?}\n */\nget last(): T { return this._results[this.length - 1]; }\n/**\n * See\n * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n * @template U\n * @param {?} fn\n * @return {?}\n */\nmap<U>(fn: (item: T, index: number, array: T[]) => U): U[] { return this._results.map(fn); }\n/**\n * See\n * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)\n * @param {?} fn\n * @return {?}\n */\nfilter(fn: (item: T, index: number, array: T[]) => boolean): T[] {\n return this._results.filter(fn);\n }\n/**\n * See\n * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)\n * @param {?} fn\n * @return {?}\n */\nfind(fn: (item: T, index: number, array: T[]) => boolean): T|undefined {\n return this._results.find(fn);\n }\n/**\n * See\n * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)\n * @template U\n * @param {?} fn\n * @param {?} init\n * @return {?}\n */\nreduce<U>(fn: (prevValue: U, curValue: T, curIndex: number, array: T[]) => U, init: U): U {\n return this._results.reduce(fn, init);\n }\n/**\n * See\n * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)\n * @param {?} fn\n * @return {?}\n */\nforEach(fn: (item: T, index: number, array: T[]) => void): void { this._results.forEach(fn); }\n/**\n * See\n * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)\n * @param {?} fn\n * @return {?}\n */\nsome(fn: (value: T, index: number, array: T[]) => boolean): boolean {\n return this._results.some(fn);\n }\n/**\n * @return {?}\n */\ntoArray(): T[] { return this._results.slice(); }\n/**\n * @return {?}\n */\n[getSymbolIterator()](): Iterator<T> { return ( /** @type {?} */((this._results as any)))[getSymbolIterator()](); }\n/**\n * @return {?}\n */\ntoString(): string { return this._results.toString(); }\n/**\n * @param {?} res\n * @return {?}\n */\nreset(res: Array<T|any[]>): void {\n this._results = flatten(res);\n this._dirty = false;\n }\n/**\n * @return {?}\n */\nnotifyOnChanges(): void { this._emitter.emit(this); }\n/**\n * internal\n * @return {?}\n */\nsetDirty() { this._dirty = true; }\n/**\n * internal\n * @return {?}\n */\nget dirty() { return this._dirty; }\n}\n\nfunction QueryList_tsickle_Closure_declarations() {\n/** @type {?} */\nQueryList.prototype._dirty;\n/** @type {?} */\nQueryList.prototype._results;\n/** @type {?} */\nQueryList.prototype._emitter;\n}\n\n/**\n * @template T\n * @param {?} list\n * @return {?}\n */\nfunction flatten<T>(list: Array<T|T[]>): T[] {\n return list.reduce((flat: any[], item: T | T[]): T[] => {\n const /** @type {?} */ flatItem = Array.isArray(item) ? flatten(item) : item;\n return ( /** @type {?} */((<T[]>flat))).concat(flatItem);\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\nimport {Injectable, Optional} from '../di';\n\nimport {Compiler} from './compiler';\nimport {NgModuleFactory} from './ng_module_factory';\nimport {NgModuleFactoryLoader} from './ng_module_factory_loader';\n\nconst /** @type {?} */ _SEPARATOR = '#';\n\nconst /** @type {?} */ FACTORY_CLASS_SUFFIX = 'NgFactory';\n/**\n * Configuration for SystemJsNgModuleLoader.\n * token.\n * \n * \\@experimental\n * @abstract\n */\nexport abstract class SystemJsNgModuleLoaderConfig {\n /**\n * Prefix to add when computing the name of the factory module for a given module name.\n */\n factoryPathPrefix: string;\n\n /**\n * Suffix to add when computing the name of the factory module for a given module name.\n */\n factoryPathSuffix: string;\n}\n\nfunction SystemJsNgModuleLoaderConfig_tsickle_Closure_declarations() {\n/**\n * Prefix to add when computing the name of the factory module for a given module name.\n * @type {?}\n */\nSystemJsNgModuleLoaderConfig.prototype.factoryPathPrefix;\n/**\n * Suffix to add when computing the name of the factory module for a given module name.\n * @type {?}\n */\nSystemJsNgModuleLoaderConfig.prototype.factoryPathSuffix;\n}\n\n\nconst /** @type {?} */ DEFAULT_CONFIG: SystemJsNgModuleLoaderConfig = {\n factoryPathPrefix: '',\n factoryPathSuffix: '.ngfactory',\n};\n/**\n * NgModuleFactoryLoader that uses SystemJS to load NgModuleFactory\n * \\@experimental\n */\nexport class SystemJsNgModuleLoader implements NgModuleFactoryLoader {\nprivate _config: SystemJsNgModuleLoaderConfig;\n/**\n * @param {?} _compiler\n * @param {?=} config\n */\nconstructor(private _compiler: Compiler, config?: SystemJsNgModuleLoaderConfig) {\n this._config = config || DEFAULT_CONFIG;\n }\n/**\n * @param {?} path\n * @return {?}\n */\nload(path: string): Promise<NgModuleFactory<any>> {\n const /** @type {?} */ offlineMode = this._compiler instanceof Compiler;\n return offlineMode ? this.loadFactory(path) : this.loadAndCompile(path);\n }\n/**\n * @param {?} path\n * @return {?}\n */\nprivate loadAndCompile(path: string): Promise<NgModuleFactory<any>> {\n let [module, exportName] = path.split(_SEPARATOR);\n if (exportName === undefined) {\n exportName = 'default';\n }\n\n return System.import(module)\n .then((module: any) => module[exportName])\n .then((type: any) => checkNotEmpty(type, module, exportName))\n .then((type: any) => this._compiler.compileModuleAsync(type));\n }\n/**\n * @param {?} path\n * @return {?}\n */\nprivate loadFactory(path: string): Promise<NgModuleFactory<any>> {\n let [module, exportName] = path.split(_SEPARATOR);\n let /** @type {?} */ factoryClassSuffix = FACTORY_CLASS_SUFFIX;\n if (exportName === undefined) {\n exportName = 'default';\n factoryClassSuffix = '';\n }\n\n return System.import(this._config.factoryPathPrefix + module + this._config.factoryPathSuffix)\n .then((module: any) => module[exportName + factoryClassSuffix])\n .then((factory: any) => checkNotEmpty(factory, module, exportName));\n }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: Compiler, },\n{type: SystemJsNgModuleLoaderConfig, decorators: [{ type: Optional }, ]},\n];\n}\n\nfunction SystemJsNgModuleLoader_tsickle_Closure_declarations() {\n/** @type {?} */\nSystemJsNgModuleLoader.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nSystemJsNgModuleLoader.ctorParameters;\n/** @type {?} */\nSystemJsNgModuleLoader.prototype._config;\n/** @type {?} */\nSystemJsNgModuleLoader.prototype._compiler;\n}\n\n/**\n * @param {?} value\n * @param {?} modulePath\n * @param {?} exportName\n * @return {?}\n */\nfunction checkNotEmpty(value: any, modulePath: string, exportName: string): any {\n if (!value) {\n throw new Error(`Cannot find '${exportName}' in '${modulePath}'`);\n }\n return value;\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 {Injectable, InjectionToken} from '../di';\nimport {MissingTranslationStrategy} from '../i18n/tokens';\nimport {ViewEncapsulation} from '../metadata';\nimport {Type} from '../type';\n\nimport {ComponentFactory} from './component_factory';\nimport {NgModuleFactory} from './ng_module_factory';\n/**\n * Combination of NgModuleFactory and ComponentFactorys.\n * \n * \\@experimental\n */\nexport class ModuleWithComponentFactories<T> {\n/**\n * @param {?} ngModuleFactory\n * @param {?} componentFactories\n */\nconstructor(\npublic ngModuleFactory: NgModuleFactory<T>,\npublic componentFactories: ComponentFactory<any>[]) {}\n}\n\nfunction ModuleWithComponentFactories_tsickle_Closure_declarations() {\n/** @type {?} */\nModuleWithComponentFactories.prototype.ngModuleFactory;\n/** @type {?} */\nModuleWithComponentFactories.prototype.componentFactories;\n}\n\n/**\n * @return {?}\n */\nfunction _throwError() {\n throw new Error(`Runtime compiler is not loaded`);\n}\n/**\n * Low-level service for running the angular compiler during runtime\n * to create {\\@link ComponentFactory}s, which\n * can later be used to create and render a Component instance.\n * \n * Each `\\@NgModule` provides an own `Compiler` to its injector,\n * that will use the directives/pipes of the ng module for compilation\n * of components.\n * \\@stable\n */\nexport class Compiler {\n/**\n * Compiles the given NgModule and all of its components. All templates of the components listed\n * in `entryComponents` have to be inlined.\n * @template T\n * @param {?} moduleType\n * @return {?}\n */\ncompileModuleSync<T>(moduleType: Type<T>): NgModuleFactory<T> { throw _throwError(); }\n/**\n * Compiles the given NgModule and all of its components\n * @template T\n * @param {?} moduleType\n * @return {?}\n */\ncompileModuleAsync<T>(moduleType: Type<T>): Promise<NgModuleFactory<T>> { throw _throwError(); }\n/**\n * Same as {\\@link #compileModuleSync} but also creates ComponentFactories for all components.\n * @template T\n * @param {?} moduleType\n * @return {?}\n */\ncompileModuleAndAllComponentsSync<T>(moduleType: Type<T>): ModuleWithComponentFactories<T> {\n throw _throwError();\n }\n/**\n * Same as {\\@link #compileModuleAsync} but also creates ComponentFactories for all components.\n * @template T\n * @param {?} moduleType\n * @return {?}\n */\ncompileModuleAndAllComponentsAsync<T>(moduleType: Type<T>):\n Promise<ModuleWithComponentFactories<T>> {\n throw _throwError();\n }\n/**\n * Exposes the CSS-style selectors that have been used in `ngContent` directives within\n * the template of the given component.\n * This is used by the `upgrade` library to compile the appropriate transclude content\n * in the AngularJS wrapper component.\n * \n * @deprecated since v4. Use ComponentFactory.ngContentSelectors instead.\n * @param {?} component\n * @return {?}\n */\ngetNgContentSelectors(component: Type<any>): string[] { throw _throwError(); }\n/**\n * Clears all caches.\n * @return {?}\n */\nclearCache(): void {}\n/**\n * Clears the cache for the given component/ngModule.\n * @param {?} type\n * @return {?}\n */\nclearCacheFor(type: Type<any>) {}\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n];\n}\n\nfunction Compiler_tsickle_Closure_declarations() {\n/** @type {?} */\nCompiler.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nCompiler.ctorParameters;\n}\n\n\n/**\n * Options for creating a compiler\n *\n * @experimental\n */\nexport type CompilerOptions = {\n /**\n * @deprecated since v4 this option has no effect anymore.\n */\n useDebug?: boolean,\n useJit?: boolean,\n defaultEncapsulation?: ViewEncapsulation,\n providers?: any[],\n missingTranslation?: MissingTranslationStrategy,\n // Whether to support the `<template>` tag and the `template` attribute to define angular\n // templates. They have been deprecated in 4.x, `<ng-template>` should be used instead.\n enableLegacyTemplate?: boolean,\n};\n/**\n * Token to provide CompilerOptions in the platform injector.\n * \n * \\@experimental\n */\nexport const COMPILER_OPTIONS = new InjectionToken<CompilerOptions[]>('compilerOptions');\n/**\n * A factory for creating a Compiler\n * \n * \\@experimental\n * @abstract\n */\nexport abstract class CompilerFactory {\n/**\n * @abstract\n * @param {?=} options\n * @return {?}\n */\ncreateCompiler(options?: CompilerOptions[]) {}\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 {global} from '../util';\n\n/**\n * A scope function for the Web Tracing Framework (WTF).\n *\n * @experimental\n */\nexport interface WtfScopeFn { (arg0?: any, arg1?: any): any; }\n\ninterface WTF {\n trace: Trace;\n}\n\ninterface Trace {\n events: Events;\n leaveScope(scope: Scope, returnValue: any): any /** TODO #9100 */;\n beginTimeRange(rangeType: string, action: string): Range;\n endTimeRange(range: Range): any /** TODO #9100 */;\n}\n\nexport interface Range {}\n\ninterface Events {\n createScope(signature: string, flags: any): Scope;\n}\n\nexport interface Scope { (...args: any[] /** TODO #9100 */): any; }\n\nlet /** @type {?} */ trace: Trace;\nlet /** @type {?} */ events: Events;\n/**\n * @return {?}\n */\nexport function detectWTF(): boolean {\n const /** @type {?} */ wtf: WTF = ( /** @type {?} */((global as any)) /** TODO #9100 */)['wtf'];\n if (wtf) {\n trace = wtf['trace'];\n if (trace) {\n events = trace['events'];\n return true;\n }\n }\n return false;\n}\n/**\n * @param {?} signature\n * @param {?=} flags\n * @return {?}\n */\nexport function createScope(signature: string, flags: any = null): any {\n return events.createScope(signature, flags);\n}\n\nexport function leave<T>(scope: Scope): void;\nexport function leave<T>(scope: Scope, returnValue?: T): T;\n/**\n * @template T\n * @param {?} scope\n * @param {?=} returnValue\n * @return {?}\n */\nexport function leave<T>(scope: Scope, returnValue?: any): any {\n trace.leaveScope(scope, returnValue);\n return returnValue;\n}\n/**\n * @param {?} rangeType\n * @param {?} action\n * @return {?}\n */\nexport function startTimeRange(rangeType: string, action: string): Range {\n return trace.beginTimeRange(rangeType, action);\n}\n/**\n * @param {?} range\n * @return {?}\n */\nexport function endTimeRange(range: Range): void {\n trace.endTimeRange(range);\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} from '../di/injector';\nimport {Type} from '../type';\nimport {stringify} from '../util';\n\nimport {ComponentFactory, ComponentRef} from './component_factory';\nimport {NgModuleRef} from './ng_module_factory';\n/**\n * @param {?} component\n * @return {?}\n */\nexport function noComponentFactoryError(component: Function) {\n const /** @type {?} */ error = Error(\n `No component factory found for ${stringify(component)}. Did you add it to @NgModule.entryComponents?`);\n ( /** @type {?} */((error as any)))[ERROR_COMPONENT] = component;\n return error;\n}\n\nconst /** @type {?} */ ERROR_COMPONENT = 'ngComponent';\n/**\n * @param {?} error\n * @return {?}\n */\nexport function getComponent(error: Error): Type<any> {\n return ( /** @type {?} */((error as any)))[ERROR_COMPONENT];\n}\nclass _NullComponentFactoryResolver implements ComponentFactoryResolver {\n/**\n * @template T\n * @param {?} component\n * @return {?}\n */\nresolveComponentFactory<T>(component: {new (...args: any[]): T}): ComponentFactory<T> {\n throw noComponentFactoryError(component);\n }\n}\n/**\n * \\@stable\n * @abstract\n */\nexport abstract class ComponentFactoryResolver {\n static NULL: ComponentFactoryResolver = new _NullComponentFactoryResolver();\n/**\n * @abstract\n * @template T\n * @param {?} component\n * @return {?}\n */\nresolveComponentFactory<T>(component: Type<T>) {}\n}\n\nfunction ComponentFactoryResolver_tsickle_Closure_declarations() {\n/** @type {?} */\nComponentFactoryResolver.NULL;\n}\n\nexport class CodegenComponentFactoryResolver implements ComponentFactoryResolver {\nprivate _factories = new Map<any, ComponentFactory<any>>();\n/**\n * @param {?} factories\n * @param {?} _parent\n * @param {?} _ngModule\n */\nconstructor(\n factories: ComponentFactory<any>[],\nprivate _parent: ComponentFactoryResolver,\nprivate _ngModule: NgModuleRef<any>) {\n for (let i = 0; i < factories.length; i++) {\n const factory = factories[i];\n this._factories.set(factory.componentType, factory);\n }\n }\n/**\n * @template T\n * @param {?} component\n * @return {?}\n */\nresolveComponentFactory<T>(component: {new (...args: any[]): T}): ComponentFactory<T> {\n let /** @type {?} */ factory = this._factories.get(component) || this._parent.resolveComponentFactory(component);\n\n return new ComponentFactoryBoundToModule(factory, this._ngModule);\n }\n}\n\nfunction CodegenComponentFactoryResolver_tsickle_Closure_declarations() {\n/** @type {?} */\nCodegenComponentFactoryResolver.prototype._factories;\n/** @type {?} */\nCodegenComponentFactoryResolver.prototype._parent;\n/** @type {?} */\nCodegenComponentFactoryResolver.prototype._ngModule;\n}\n\nexport class ComponentFactoryBoundToModule<C> extends ComponentFactory<C> {\n/**\n * @param {?} factory\n * @param {?} ngModule\n */\nconstructor(private factory: ComponentFactory<C>,\nprivate ngModule: NgModuleRef<any>) { super(); }\n/**\n * @return {?}\n */\nget selector() { return this.factory.selector; }\n/**\n * @return {?}\n */\nget componentType() { return this.factory.componentType; }\n/**\n * @return {?}\n */\nget ngContentSelectors() { return this.factory.ngContentSelectors; }\n/**\n * @return {?}\n */\nget inputs() { return this.factory.inputs; }\n/**\n * @return {?}\n */\nget outputs() { return this.factory.outputs; }\n/**\n * @param {?} injector\n * @param {?=} projectableNodes\n * @param {?=} rootSelectorOrNode\n * @param {?=} ngModule\n * @return {?}\n */\ncreate(\n injector: Injector, projectableNodes?: any[][], rootSelectorOrNode?: string|any,\n ngModule?: NgModuleRef<any>): ComponentRef<C> {\n return this.factory.create(\n injector, projectableNodes, rootSelectorOrNode, ngModule || this.ngModule);\n }\n}\n\nfunction ComponentFactoryBoundToModule_tsickle_Closure_declarations() {\n/** @type {?} */\nComponentFactoryBoundToModule.prototype.factory;\n/** @type {?} */\nComponentFactoryBoundToModule.prototype.ngModule;\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, THROW_IF_NOT_FOUND} from '../di/injector';\nimport {Type} from '../type';\nimport {stringify} from '../util';\n\nimport {ComponentFactory} from './component_factory';\nimport {CodegenComponentFactoryResolver, ComponentFactoryBoundToModule, ComponentFactoryResolver} from './component_factory_resolver';\n/**\n * Represents an instance of an NgModule created via a {\\@link NgModuleFactory}.\n * \n * `NgModuleRef` provides access to the NgModule Instance as well other objects related to this\n * NgModule Instance.\n * \n * \\@stable\n * @abstract\n */\nexport abstract class NgModuleRef<T> {\n/**\n * The injector that contains all of the providers of the NgModule.\n * @abstract\n * @return {?}\n */\ninjector() {}\n/**\n * The ComponentFactoryResolver to get hold of the ComponentFactories\n * declared in the `entryComponents` property of the module.\n * @abstract\n * @return {?}\n */\ncomponentFactoryResolver() {}\n/**\n * The NgModule instance.\n * @abstract\n * @return {?}\n */\ninstance() {}\n/**\n * Destroys the module instance and all of the data structures associated with it.\n * @abstract\n * @return {?}\n */\ndestroy() {}\n/**\n * Allows to register a callback that will be called when the module is destroyed.\n * @abstract\n * @param {?} callback\n * @return {?}\n */\nonDestroy(callback: () => void) {}\n}\n/**\n * \\@experimental\n */\nexport class NgModuleFactory<T> {\n/**\n * @param {?} _injectorClass\n * @param {?} _moduleType\n */\nconstructor(\nprivate _injectorClass: {new (parentInjector: Injector): NgModuleInjector<T>},\nprivate _moduleType: Type<T>) {}\n/**\n * @return {?}\n */\nget moduleType(): Type<T> { return this._moduleType; }\n/**\n * @param {?} parentInjector\n * @return {?}\n */\ncreate(parentInjector: Injector|null): NgModuleRef<T> {\n const /** @type {?} */ instance = new this._injectorClass(parentInjector || Injector.NULL);\n instance.create();\n return instance;\n }\n}\n\nfunction NgModuleFactory_tsickle_Closure_declarations() {\n/** @type {?} */\nNgModuleFactory.prototype._injectorClass;\n/** @type {?} */\nNgModuleFactory.prototype._moduleType;\n}\n\n\nconst /** @type {?} */ _UNDEFINED = new Object();\n/**\n * @abstract\n */\nexport abstract class NgModuleInjector<T> implements Injector, NgModuleRef<T> {\n bootstrapFactories: ComponentFactory<any>[];\n instance: T;\nprivate _destroyListeners: (() => void)[] = [];\nprivate _destroyed: boolean = false;\nprivate _cmpFactoryResolver: CodegenComponentFactoryResolver;\n/**\n * @param {?} parent\n * @param {?} factories\n * @param {?} bootstrapFactories\n */\nconstructor(\npublic parent: Injector, factories: ComponentFactory<any>[],\n bootstrapFactories: ComponentFactory<any>[]) {\n this.bootstrapFactories =\n bootstrapFactories.map(f => new ComponentFactoryBoundToModule(f, this));\n this._cmpFactoryResolver = new CodegenComponentFactoryResolver(\n factories, parent.get(ComponentFactoryResolver, ComponentFactoryResolver.NULL), this);\n }\n/**\n * @return {?}\n */\ncreate() { this.instance = this.createInternal(); }\n/**\n * @abstract\n * @return {?}\n */\ncreateInternal() {}\n/**\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\nget(token: any, notFoundValue: any = THROW_IF_NOT_FOUND): any {\n if (token === Injector || token === NgModuleRef) {\n return this;\n }\n\n if (token === ComponentFactoryResolver) {\n return this._cmpFactoryResolver;\n }\n\n const /** @type {?} */ result = this.getInternal(token, _UNDEFINED);\n return result === _UNDEFINED ? this.parent.get(token, notFoundValue) : result;\n }\n/**\n * @abstract\n * @param {?} token\n * @param {?} notFoundValue\n * @return {?}\n */\ngetInternal(token: any, notFoundValue: any) {}\n/**\n * @return {?}\n */\nget injector(): Injector { return this; }\n/**\n * @return {?}\n */\nget componentFactoryResolver(): ComponentFactoryResolver { return this._cmpFactoryResolver; }\n/**\n * @return {?}\n */\ndestroy(): void {\n if (this._destroyed) {\n throw new Error(\n `The ng module ${stringify(this.instance.constructor)} has already been destroyed.`);\n }\n this._destroyed = true;\n this.destroyInternal();\n this._destroyListeners.forEach((listener) => listener());\n }\n/**\n * @param {?} callback\n * @return {?}\n */\nonDestroy(callback: () => void): void { this._destroyListeners.push(callback); }\n/**\n * @abstract\n * @return {?}\n */\ndestroyInternal() {}\n}\n\nfunction NgModuleInjector_tsickle_Closure_declarations() {\n/** @type {?} */\nNgModuleInjector.prototype.bootstrapFactories;\n/** @type {?} */\nNgModuleInjector.prototype.instance;\n/** @type {?} */\nNgModuleInjector.prototype._destroyListeners;\n/** @type {?} */\nNgModuleInjector.prototype._destroyed;\n/** @type {?} */\nNgModuleInjector.prototype._cmpFactoryResolver;\n/** @type {?} */\nNgModuleInjector.prototype.parent;\n}\n\n","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n\nimport {Subject} from 'rxjs/Subject';\n/**\n * Use by directives and components to emit custom Events.\n * \n * ### Examples\n * \n * In the following example, `Zippy` alternatively emits `open` and `close` events when its\n * title gets clicked:\n * \n * ```\n * \\@Component({ \n * selector: 'zippy',\n * template: `\n * <div class=\"zippy\">\n * <div (click)=\"toggle()\">Toggle</div>\n * <div [hidden]=\"!visible\">\n * <ng-content></ng-content>\n * </div>\n * </div>`})\n * export class Zippy {\n * visible: boolean = true;\n * \\@Output() open: EventEmitter<any> = new EventEmitter();\n * \\@Output() close: EventEmitter<any> = new EventEmitter();\n * \n * toggle() {\n * this.visible = !this.visible;\n * if (this.visible) {\n * this.open.emit(null);\n * } else {\n * this.close.emit(null);\n * }\n * }\n * }\n * ```\n * \n * The events payload can be accessed by the parameter `$event` on the components output event\n * handler:\n * \n * ```\n * <zippy (open)=\"onOpen($event)\" (close)=\"onClose($event)\"></zippy>\n * ```\n * \n * Uses Rx.Observable but provides an adapter to make it work as specified here:\n * https://github.com/jhusain/observable-spec\n * \n * Once a reference implementation of the spec is available, switch to it.\n * \\@stable\n */\nexport class EventEmitter<T> extends Subject<T> {\n // TODO: mark this as internal once all the facades are gone\n // we can't mark it as internal now because EventEmitter exported via @angular/core would not\n // contain this property making it incompatible with all the code that uses EventEmitter via\n // facades, which are local to the code and do not have this property stripped.\n // tslint:disable-next-line\n __isAsync: boolean;\n/**\n * Creates an instance of [EventEmitter], which depending on [isAsync],\n * delivers events synchronously or asynchronously.\n * @param {?=} isAsync\n */\nconstructor(isAsync: boolean = false) {\n super();\n this.__isAsync = isAsync;\n }\n/**\n * @param {?=} value\n * @return {?}\n */\nemit(value?: T) { super.next(value); }\n/**\n * @param {?=} generatorOrNext\n * @param {?=} error\n * @param {?=} complete\n * @return {?}\n */\nsubscribe(generatorOrNext?: any, error?: any, complete?: any): any {\n let /** @type {?} */ schedulerFn: (t: any) => any;\n let /** @type {?} */ errorFn = (err: any): any => null;\n let /** @type {?} */ completeFn = (): any => null;\n\n if (generatorOrNext && typeof generatorOrNext === 'object') {\n schedulerFn = this.__isAsync ? (value: any) => {\n setTimeout(() => generatorOrNext.next(value));\n } : (value: any) => { generatorOrNext.next(value); };\n\n if (generatorOrNext.error) {\n errorFn = this.__isAsync ? (err) => { setTimeout(() => generatorOrNext.error(err)); } :\n (err) => { generatorOrNext.error(err); };\n }\n\n if (generatorOrNext.complete) {\n completeFn = this.__isAsync ? () => { setTimeout(() => generatorOrNext.complete()); } :\n () => { generatorOrNext.complete(); };\n }\n } else {\n schedulerFn = this.__isAsync ? (value: any) => { setTimeout(() => generatorOrNext(value)); } :\n (value: any) => { generatorOrNext(value); };\n\n if (error) {\n errorFn =\n this.__isAsync ? (err) => { setTimeout(() => error(err)); } : (err) => { error(err); };\n }\n\n if (complete) {\n completeFn =\n this.__isAsync ? () => { setTimeout(() => complete()); } : () => { complete(); };\n }\n }\n\n return super.subscribe(schedulerFn, errorFn, completeFn);\n }\n}\n\nfunction EventEmitter_tsickle_Closure_declarations() {\n/** @type {?} */\nEventEmitter.prototype.__isAsync;\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 {EventEmitter} from '../event_emitter';\n/**\n * An injectable service for executing work inside or outside of the Angular zone.\n * \n * The most common use of this service is to optimize performance when starting a work consisting of\n * one or more asynchronous tasks that don't require UI updates or error handling to be handled by\n * Angular. Such tasks can be kicked off via {\\@link #runOutsideAngular} and if needed, these tasks\n * can reenter the Angular zone via {\\@link #run}.\n * \n * <!-- TODO: add/fix links to:\n * - docs explaining zones and the use of zones in Angular and change-detection\n * - link to runOutsideAngular/run (throughout this file!)\n * -->\n * \n * ### Example\n * \n * ```\n * import {Component, NgZone} from '\\@angular/core';\n * import {NgIf} from '\\@angular/common';\n * \n * \\@Component({ \n * selector: 'ng-zone-demo'.\n * template: `\n * <h2>Demo: NgZone</h2>\n * \n * <p>Progress: {{progress}}%</p>\n * <p *ngIf=\"progress >= 100\">Done processing {{label}} of Angular zone!</p>\n * \n * <button (click)=\"processWithinAngularZone()\">Process within Angular zone</button>\n * <button (click)=\"processOutsideOfAngularZone()\">Process outside of Angular zone</button>\n * `,\n * })\n * export class NgZoneDemo {\n * progress: number = 0;\n * label: string;\n * \n * constructor(private _ngZone: NgZone) {}\n * \n * // Loop inside the Angular zone\n * // so the UI DOES refresh after each setTimeout cycle\n * processWithinAngularZone() {\n * this.label = 'inside';\n * this.progress = 0;\n * this._increaseProgress(() => console.log('Inside Done!'));\n * }\n * \n * // Loop outside of the Angular zone\n * // so the UI DOES NOT refresh after each setTimeout cycle\n * processOutsideOfAngularZone() {\n * this.label = 'outside';\n * this.progress = 0;\n * this._ngZone.runOutsideAngular(() => {\n * this._increaseProgress(() => {\n * // reenter the Angular zone and display done\n * this._ngZone.run(() => {console.log('Outside Done!') });\n * }}));\n * }\n * \n * _increaseProgress(doneCallback: () => void) {\n * this.progress += 1;\n * console.log(`Current progress: ${this.progress}%`);\n * \n * if (this.progress < 100) {\n * window.setTimeout(() => this._increaseProgress(doneCallback)), 10)\n * } else {\n * doneCallback();\n * }\n * }\n * }\n * ```\n * \n * \\@experimental\n */\nexport class NgZone {\nprivate outer: Zone;\nprivate inner: Zone;\nprivate _hasPendingMicrotasks: boolean = false;\nprivate _hasPendingMacrotasks: boolean = false;\nprivate _isStable = true;\nprivate _nesting: number = 0;\nprivate _onUnstable: EventEmitter<any> = new EventEmitter(false);\nprivate _onMicrotaskEmpty: EventEmitter<any> = new EventEmitter(false);\nprivate _onStable: EventEmitter<any> = new EventEmitter(false);\nprivate _onErrorEvents: EventEmitter<any> = new EventEmitter(false);\n/**\n * @param {?} __0\n */\nconstructor({enableLongStackTrace = false}) {\n if (typeof Zone == 'undefined') {\n throw new Error('Angular requires Zone.js prolyfill.');\n }\n\n Zone.assertZonePatched();\n\n this.outer = this.inner = Zone.current;\n\n if ((Zone as any)['wtfZoneSpec']) {\n this.inner = this.inner.fork((Zone as any)['wtfZoneSpec']);\n }\n\n if (enableLongStackTrace && (Zone as any)['longStackTraceZoneSpec']) {\n this.inner = this.inner.fork((Zone as any)['longStackTraceZoneSpec']);\n }\n\n this.forkInnerZoneWithAngularBehavior();\n }\n/**\n * @return {?}\n */\nstatic isInAngularZone(): boolean { return Zone.current.get('isAngularZone') === true; }\n/**\n * @return {?}\n */\nstatic assertInAngularZone(): void {\n if (!NgZone.isInAngularZone()) {\n throw new Error('Expected to be in Angular Zone, but it is not!');\n }\n }\n/**\n * @return {?}\n */\nstatic assertNotInAngularZone(): void {\n if (NgZone.isInAngularZone()) {\n throw new Error('Expected to not be in Angular Zone, but it is!');\n }\n }\n/**\n * Executes the `fn` function synchronously within the Angular zone and returns value returned by\n * the function.\n * \n * Running functions via `run` allows you to reenter Angular zone from a task that was executed\n * outside of the Angular zone (typically started via {\\@link #runOutsideAngular}).\n * \n * Any future tasks or microtasks scheduled from within this function will continue executing from\n * within the Angular zone.\n * \n * If a synchronous error happens it will be rethrown and not reported via `onError`.\n * @param {?} fn\n * @return {?}\n */\nrun(fn: () => any): any { return this.inner.run(fn); }\n/**\n * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not\n * rethrown.\n * @param {?} fn\n * @return {?}\n */\nrunGuarded(fn: () => any): any { return this.inner.runGuarded(fn); }\n/**\n * Executes the `fn` function synchronously in Angular's parent zone and returns value returned by\n * the function.\n * \n * Running functions via {\\@link #runOutsideAngular} allows you to escape Angular's zone and do\n * work that\n * doesn't trigger Angular change-detection or is subject to Angular's error handling.\n * \n * Any future tasks or microtasks scheduled from within this function will continue executing from\n * outside of the Angular zone.\n * \n * Use {\\@link #run} to reenter the Angular zone and do work that updates the application model.\n * @param {?} fn\n * @return {?}\n */\nrunOutsideAngular(fn: () => any): any { return this.outer.run(fn); }\n/**\n * Notifies when code enters Angular Zone. This gets fired first on VM Turn.\n * @return {?}\n */\nget onUnstable(): EventEmitter<any> { return this._onUnstable; }\n/**\n * Notifies when there is no more microtasks enqueue in the current VM Turn.\n * This is a hint for Angular to do change detection, which may enqueue more microtasks.\n * For this reason this event can fire multiple times per VM Turn.\n * @return {?}\n */\nget onMicrotaskEmpty(): EventEmitter<any> { return this._onMicrotaskEmpty; }\n/**\n * Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which\n * implies we are about to relinquish VM turn.\n * This event gets called just once.\n * @return {?}\n */\nget onStable(): EventEmitter<any> { return this._onStable; }\n/**\n * Notify that an error has been delivered.\n * @return {?}\n */\nget onError(): EventEmitter<any> { return this._onErrorEvents; }\n/**\n * Whether there are no outstanding microtasks or macrotasks.\n * @return {?}\n */\nget isStable(): boolean { return this._isStable; }\n/**\n * @return {?}\n */\nget hasPendingMicrotasks(): boolean { return this._hasPendingMicrotasks; }\n/**\n * @return {?}\n */\nget hasPendingMacrotasks(): boolean { return this._hasPendingMacrotasks; }\n/**\n * @return {?}\n */\nprivate checkStable() {\n if (this._nesting == 0 && !this._hasPendingMicrotasks && !this._isStable) {\n try {\n this._nesting++;\n this._onMicrotaskEmpty.emit(null);\n } finally {\n this._nesting--;\n if (!this._hasPendingMicrotasks) {\n try {\n this.runOutsideAngular(() => this._onStable.emit(null));\n } finally {\n this._isStable = true;\n }\n }\n }\n }\n }\n/**\n * @return {?}\n */\nprivate forkInnerZoneWithAngularBehavior() {\n this.inner = this.inner.fork({\n name: 'angular',\n properties: /** @type {?} */(( <any>{'isAngularZone': true})),\n onInvokeTask: (delegate: ZoneDelegate, current: Zone, target: Zone, task: Task,\n applyThis: any, applyArgs: any): any => {\n try {\n this.onEnter();\n return delegate.invokeTask(target, task, applyThis, applyArgs);\n } finally {\n this.onLeave();\n }\n },\n\n\n onInvoke: (delegate: ZoneDelegate, current: Zone, target: Zone, callback: Function,\n applyThis: any, applyArgs: any[], source: string): any => {\n try {\n this.onEnter();\n return delegate.invoke(target, callback, applyThis, applyArgs, source);\n } finally {\n this.onLeave();\n }\n },\n\n onHasTask:\n (delegate: ZoneDelegate, current: Zone, target: Zone, hasTaskState: HasTaskState) => {\n delegate.hasTask(target, hasTaskState);\n if (current === target) {\n // We are only interested in hasTask events which originate from our zone\n // (A child hasTask event is not interesting to us)\n if (hasTaskState.change == 'microTask') {\n this.setHasMicrotask(hasTaskState.microTask);\n } else if (hasTaskState.change == 'macroTask') {\n this.setHasMacrotask(hasTaskState.macroTask);\n }\n }\n },\n\n onHandleError: (delegate: ZoneDelegate, current: Zone, target: Zone, error: any): boolean => {\n delegate.handleError(target, error);\n this.triggerError(error);\n return false;\n }\n });\n }\n/**\n * @return {?}\n */\nprivate onEnter() {\n this._nesting++;\n if (this._isStable) {\n this._isStable = false;\n this._onUnstable.emit(null);\n }\n }\n/**\n * @return {?}\n */\nprivate onLeave() {\n this._nesting--;\n this.checkStable();\n }\n/**\n * @param {?} hasMicrotasks\n * @return {?}\n */\nprivate setHasMicrotask(hasMicrotasks: boolean) {\n this._hasPendingMicrotasks = hasMicrotasks;\n this.checkStable();\n }\n/**\n * @param {?} hasMacrotasks\n * @return {?}\n */\nprivate setHasMacrotask(hasMacrotasks: boolean) { this._hasPendingMacrotasks = hasMacrotasks; }\n/**\n * @param {?} error\n * @return {?}\n */\nprivate triggerError(error: any) { this._onErrorEvents.emit(error); }\n}\n\nfunction NgZone_tsickle_Closure_declarations() {\n/** @type {?} */\nNgZone.prototype.outer;\n/** @type {?} */\nNgZone.prototype.inner;\n/** @type {?} */\nNgZone.prototype._hasPendingMicrotasks;\n/** @type {?} */\nNgZone.prototype._hasPendingMacrotasks;\n/** @type {?} */\nNgZone.prototype._isStable;\n/** @type {?} */\nNgZone.prototype._nesting;\n/** @type {?} */\nNgZone.prototype._onUnstable;\n/** @type {?} */\nNgZone.prototype._onMicrotaskEmpty;\n/** @type {?} */\nNgZone.prototype._onStable;\n/** @type {?} */\nNgZone.prototype._onErrorEvents;\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 {Injectable} from '../di';\nimport {scheduleMicroTask} from '../util';\nimport {NgZone} from '../zone/ng_zone';\n\n/**\n * Testability API.\n * `declare` keyword causes tsickle to generate externs, so these methods are\n * not renamed by Closure Compiler.\n * @experimental\n */\nexport declare interface PublicTestability {\n isStable(): boolean;\n whenStable(callback: Function): void;\n findProviders(using: any, provider: string, exactMatch: boolean): any[];\n}\n/**\n * The Testability service provides testing hooks that can be accessed from\n * the browser and by services such as Protractor. Each bootstrapped Angular\n * application on the page will have an instance of Testability.\n * \\@experimental\n */\nexport class Testability implements PublicTestability {\n/**\n * \\@internal\n */\n_pendingCount: number = 0;\n/**\n * \\@internal\n */\n_isZoneStable: boolean = true;\n/**\n * Whether any work was done since the last 'whenStable' callback. This is\n * useful to detect if this could have potentially destabilized another\n * component while it is stabilizing.\n * \\@internal\n */\n_didWork: boolean = false;\n/**\n * \\@internal\n */\n_callbacks: Function[] = [];\n/**\n * @param {?} _ngZone\n */\nconstructor(private _ngZone: NgZone) { this._watchAngularEvents(); }\n/**\n * \\@internal\n * @return {?}\n */\n_watchAngularEvents(): void {\n this._ngZone.onUnstable.subscribe({\n next: () => {\n this._didWork = true;\n this._isZoneStable = false;\n }\n });\n\n this._ngZone.runOutsideAngular(() => {\n this._ngZone.onStable.subscribe({\n next: () => {\n NgZone.assertNotInAngularZone();\n scheduleMicroTask(() => {\n this._isZoneStable = true;\n this._runCallbacksIfReady();\n });\n }\n });\n });\n }\n/**\n * @return {?}\n */\nincreasePendingRequestCount(): number {\n this._pendingCount += 1;\n this._didWork = true;\n return this._pendingCount;\n }\n/**\n * @return {?}\n */\ndecreasePendingRequestCount(): number {\n this._pendingCount -= 1;\n if (this._pendingCount < 0) {\n throw new Error('pending async requests below zero');\n }\n this._runCallbacksIfReady();\n return this._pendingCount;\n }\n/**\n * @return {?}\n */\nisStable(): boolean {\n return this._isZoneStable && this._pendingCount == 0 && !this._ngZone.hasPendingMacrotasks;\n }\n/**\n * \\@internal\n * @return {?}\n */\n_runCallbacksIfReady(): void {\n if (this.isStable()) {\n // Schedules the call backs in a new frame so that it is always async.\n scheduleMicroTask(() => {\n while (this._callbacks.length !== 0) {\n ( /** @type {?} */((this._callbacks.pop())))(this._didWork);\n }\n this._didWork = false;\n });\n } else {\n // Not Ready\n this._didWork = true;\n }\n }\n/**\n * @param {?} callback\n * @return {?}\n */\nwhenStable(callback: Function): void {\n this._callbacks.push(callback);\n this._runCallbacksIfReady();\n }\n/**\n * @return {?}\n */\ngetPendingRequestCount(): number { return this._pendingCount; }\n/**\n * @deprecated use findProviders\n * @param {?} using\n * @param {?} provider\n * @param {?} exactMatch\n * @return {?}\n */\nfindBindings(using: any, provider: string, exactMatch: boolean): any[] {\n // TODO(juliemr): implement.\n return [];\n }\n/**\n * @param {?} using\n * @param {?} provider\n * @param {?} exactMatch\n * @return {?}\n */\nfindProviders(using: any, provider: string, exactMatch: boolean): any[] {\n // TODO(juliemr): implement.\n return [];\n }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: NgZone, },\n];\n}\n\nfunction Testability_tsickle_Closure_declarations() {\n/** @type {?} */\nTestability.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nTestability.ctorParameters;\n/**\n * \\@internal\n * @type {?}\n */\nTestability.prototype._pendingCount;\n/**\n * \\@internal\n * @type {?}\n */\nTestability.prototype._isZoneStable;\n/**\n * Whether any work was done since the last 'whenStable' callback. This is\n * useful to detect if this could have potentially destabilized another\n * component while it is stabilizing.\n * \\@internal\n * @type {?}\n */\nTestability.prototype._didWork;\n/**\n * \\@internal\n * @type {?}\n */\nTestability.prototype._callbacks;\n/** @type {?} */\nTestability.prototype._ngZone;\n}\n\n/**\n * A global registry of {\\@link Testability} instances for specific elements.\n * \\@experimental\n */\nexport class TestabilityRegistry {\n/**\n * \\@internal\n */\n_applications = new Map<any, Testability>();\nconstructor() { _testabilityGetter.addToWindow(this); }\n/**\n * @param {?} token\n * @param {?} testability\n * @return {?}\n */\nregisterApplication(token: any, testability: Testability) {\n this._applications.set(token, testability);\n }\n/**\n * @param {?} elem\n * @return {?}\n */\ngetTestability(elem: any): Testability|null { return this._applications.get(elem) || null; }\n/**\n * @return {?}\n */\ngetAllTestabilities(): Testability[] { return Array.from(this._applications.values()); }\n/**\n * @return {?}\n */\ngetAllRootElements(): any[] { return Array.from(this._applications.keys()); }\n/**\n * @param {?} elem\n * @param {?=} findInAncestors\n * @return {?}\n */\nfindTestabilityInTree(elem: Node, findInAncestors: boolean = true): Testability|null {\n return _testabilityGetter.findTestabilityInTree(this, elem, findInAncestors);\n }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n];\n}\n\nfunction TestabilityRegistry_tsickle_Closure_declarations() {\n/** @type {?} */\nTestabilityRegistry.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nTestabilityRegistry.ctorParameters;\n/**\n * \\@internal\n * @type {?}\n */\nTestabilityRegistry.prototype._applications;\n}\n\n\n/**\n * Adapter interface for retrieving the `Testability` service associated for a\n * particular context.\n *\n * @experimental Testability apis are primarily intended to be used by e2e test tool vendors like\n * the Protractor team.\n */\nexport interface GetTestability {\n addToWindow(registry: TestabilityRegistry): void;\n findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean):\n Testability|null;\n}\nclass _NoopGetTestability implements GetTestability {\n/**\n * @param {?} registry\n * @return {?}\n */\naddToWindow(registry: TestabilityRegistry): void {}\n/**\n * @param {?} registry\n * @param {?} elem\n * @param {?} findInAncestors\n * @return {?}\n */\nfindTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean):\n Testability|null {\n return null;\n }\n}\n/**\n * Set the {\\@link GetTestability} implementation used by the Angular testing framework.\n * \\@experimental\n * @param {?} getter\n * @return {?}\n */\nexport function setTestabilityGetter(getter: GetTestability): void {\n _testabilityGetter = getter;\n}\n\nlet /** @type {?} */ _testabilityGetter: GetTestability = new _NoopGetTestability();\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 {Observable} from 'rxjs/Observable';\nimport {Observer} from 'rxjs/Observer';\nimport {Subscription} from 'rxjs/Subscription';\nimport {merge} from 'rxjs/observable/merge';\nimport {share} from 'rxjs/operator/share';\n\nimport {ErrorHandler} from '../src/error_handler';\nimport {scheduleMicroTask, stringify} from '../src/util';\nimport {isPromise} from '../src/util/lang';\n\nimport {ApplicationInitStatus} from './application_init';\nimport {APP_BOOTSTRAP_LISTENER, PLATFORM_INITIALIZER} from './application_tokens';\nimport {Console} from './console';\nimport {Injectable, InjectionToken, Injector, Provider, ReflectiveInjector} from './di';\nimport {CompilerFactory, CompilerOptions} from './linker/compiler';\nimport {ComponentFactory, ComponentRef} from './linker/component_factory';\nimport {ComponentFactoryBoundToModule, ComponentFactoryResolver} from './linker/component_factory_resolver';\nimport {NgModuleFactory, NgModuleInjector, NgModuleRef} from './linker/ng_module_factory';\nimport {InternalViewRef, ViewRef} from './linker/view_ref';\nimport {WtfScopeFn, wtfCreateScope, wtfLeave} from './profile/profile';\nimport {Testability, TestabilityRegistry} from './testability/testability';\nimport {Type} from './type';\nimport {NgZone} from './zone/ng_zone';\n\nlet /** @type {?} */ _devMode: boolean = true;\nlet /** @type {?} */ _runModeLocked: boolean = false;\nlet /** @type {?} */ _platform: PlatformRef;\n\nexport const /** @type {?} */ ALLOW_MULTIPLE_PLATFORMS = new InjectionToken<boolean>('AllowMultipleToken');\n/**\n * Disable Angular's development mode, which turns off assertions and other\n * checks within the framework.\n * \n * One important assertion this disables verifies that a change detection pass\n * does not result in additional changes to any bindings (also known as\n * unidirectional data flow).\n * \n * \\@stable\n * @return {?}\n */\nexport function enableProdMode(): void {\n if (_runModeLocked) {\n throw new Error('Cannot enable prod mode after platform setup.');\n }\n _devMode = false;\n}\n/**\n * Returns whether Angular is in development mode. After called once,\n * the value is locked and won't change any more.\n * \n * By default, this is true, unless a user calls `enableProdMode` before calling this.\n * \n * \\@experimental APIs related to application bootstrap are currently under review.\n * @return {?}\n */\nexport function isDevMode(): boolean {\n _runModeLocked = true;\n return _devMode;\n}\n/**\n * A token for third-party components that can register themselves with NgProbe.\n * \n * \\@experimental\n */\nexport class NgProbeToken {\n/**\n * @param {?} name\n * @param {?} token\n */\nconstructor(public name: string,\npublic token: any) {}\n}\n\nfunction NgProbeToken_tsickle_Closure_declarations() {\n/** @type {?} */\nNgProbeToken.prototype.name;\n/** @type {?} */\nNgProbeToken.prototype.token;\n}\n\n/**\n * Creates a platform.\n * Platforms have to be eagerly created via this function.\n * \n * \\@experimental APIs related to application bootstrap are currently under review.\n * @param {?} injector\n * @return {?}\n */\nexport function createPlatform(injector: Injector): PlatformRef {\n if (_platform && !_platform.destroyed &&\n !_platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {\n throw new Error(\n 'There can be only one platform. Destroy the previous one to create a new one.');\n }\n _platform = injector.get(PlatformRef);\n const /** @type {?} */ inits = injector.get(PLATFORM_INITIALIZER, null);\n if (inits) inits.forEach((init: any) => init());\n return _platform;\n}\n/**\n * Creates a factory for a platform\n * \n * \\@experimental APIs related to application bootstrap are currently under review.\n * @param {?} parentPlatformFactory\n * @param {?} name\n * @param {?=} providers\n * @return {?}\n */\nexport function createPlatformFactory(\n parentPlatformFactory: ((extraProviders?: Provider[]) => PlatformRef) | null, name: string,\n providers: Provider[] = []): (extraProviders?: Provider[]) => PlatformRef {\n const /** @type {?} */ marker = new InjectionToken(`Platform: ${name}`);\n return (extraProviders: Provider[] = []) => {\n let /** @type {?} */ platform = getPlatform();\n if (!platform || platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {\n if (parentPlatformFactory) {\n parentPlatformFactory(\n providers.concat(extraProviders).concat({provide: marker, useValue: true}));\n } else {\n createPlatform(ReflectiveInjector.resolveAndCreate(\n providers.concat(extraProviders).concat({provide: marker, useValue: true})));\n }\n }\n return assertPlatform(marker);\n };\n}\n/**\n * Checks that there currently is a platform which contains the given token as a provider.\n * \n * \\@experimental APIs related to application bootstrap are currently under review.\n * @param {?} requiredToken\n * @return {?}\n */\nexport function assertPlatform(requiredToken: any): PlatformRef {\n const /** @type {?} */ platform = getPlatform();\n\n if (!platform) {\n throw new Error('No platform exists!');\n }\n\n if (!platform.injector.get(requiredToken, null)) {\n throw new Error(\n 'A platform with a different configuration has been created. Please destroy it first.');\n }\n\n return platform;\n}\n/**\n * Destroy the existing platform.\n * \n * \\@experimental APIs related to application bootstrap are currently under review.\n * @return {?}\n */\nexport function destroyPlatform(): void {\n if (_platform && !_platform.destroyed) {\n _platform.destroy();\n }\n}\n/**\n * Returns the current platform.\n * \n * \\@experimental APIs related to application bootstrap are currently under review.\n * @return {?}\n */\nexport function getPlatform(): PlatformRef|null {\n return _platform && !_platform.destroyed ? _platform : null;\n}\n/**\n * The Angular platform is the entry point for Angular on a web page. Each page\n * has exactly one platform, and services (such as reflection) which are common\n * to every Angular application running on the page are bound in its scope.\n * \n * A page's platform is initialized implicitly when a platform is created via a platform factory\n * (e.g. {\\@link platformBrowser}), or explicitly by calling the {\\@link createPlatform} function.\n * \n * \\@stable\n * @abstract\n */\nexport abstract class PlatformRef {\n/**\n * Creates an instance of an `\\@NgModule` for the given platform\n * for offline compilation.\n * \n * ## Simple Example\n * \n * ```typescript\n * my_module.ts:\n * \n * \\@NgModule({ \n * imports: [BrowserModule]\n * })\n * class MyModule {}\n * \n * main.ts:\n * import {MyModuleNgFactory} from './my_module.ngfactory';\n * import {platformBrowser} from '\\@angular/platform-browser';\n * \n * let moduleRef = platformBrowser().bootstrapModuleFactory(MyModuleNgFactory);\n * ```\n * \n * \\@experimental APIs related to application bootstrap are currently under review.\n * @abstract\n * @template M\n * @param {?} moduleFactory\n * @return {?}\n */\nbootstrapModuleFactory<M>(moduleFactory: NgModuleFactory<M>) {}\n/**\n * Creates an instance of an `\\@NgModule` for a given platform using the given runtime compiler.\n * \n * ## Simple Example\n * \n * ```typescript\n * \\@NgModule({ \n * imports: [BrowserModule]\n * })\n * class MyModule {}\n * \n * let moduleRef = platformBrowser().bootstrapModule(MyModule);\n * ```\n * \\@stable\n * @abstract\n * @template M\n * @param {?} moduleType\n * @param {?=} compilerOptions\n * @return {?}\n */\nbootstrapModule<M>(\n moduleType: Type<M>,\n compilerOptions?: CompilerOptions|CompilerOptions[]) {}\n/**\n * Register a listener to be called when the platform is disposed.\n * @abstract\n * @param {?} callback\n * @return {?}\n */\nonDestroy(callback: () => void) {}\n/**\n * Retrieve the platform {\\@link Injector}, which is the parent injector for\n * every Angular application on the page and provides singleton providers.\n * @abstract\n * @return {?}\n */\ninjector() {}\n/**\n * Destroy the Angular platform and all Angular applications on the page.\n * @abstract\n * @return {?}\n */\ndestroy() {}\n/**\n * @abstract\n * @return {?}\n */\ndestroyed() {}\n}\n/**\n * @param {?} errorHandler\n * @param {?} callback\n * @return {?}\n */\nfunction _callAndReportToErrorHandler(errorHandler: ErrorHandler, callback: () => any): any {\n try {\n const /** @type {?} */ result = callback();\n if (isPromise(result)) {\n return result.catch((e: any) => {\n errorHandler.handleError(e);\n // rethrow as the exception handler might not do it\n throw e;\n });\n }\n\n return result;\n } catch ( /** @type {?} */e) {\n errorHandler.handleError(e);\n // rethrow as the exception handler might not do it\n throw e;\n }\n}\n/**\n * workaround https://github.com/angular/tsickle/issues/350\n * @suppress {checkTypes}\n */\nexport class PlatformRef_ extends PlatformRef {\nprivate _modules: NgModuleRef<any>[] = [];\nprivate _destroyListeners: Function[] = [];\nprivate _destroyed: boolean = false;\n/**\n * @param {?} _injector\n */\nconstructor(private _injector: Injector) { super(); }\n/**\n * @param {?} callback\n * @return {?}\n */\nonDestroy(callback: () => void): void { this._destroyListeners.push(callback); }\n/**\n * @return {?}\n */\nget injector(): Injector { return this._injector; }\n/**\n * @return {?}\n */\nget destroyed() { return this._destroyed; }\n/**\n * @return {?}\n */\ndestroy() {\n if (this._destroyed) {\n throw new Error('The platform has already been destroyed!');\n }\n this._modules.slice().forEach(module => module.destroy());\n this._destroyListeners.forEach(listener => listener());\n this._destroyed = true;\n }\n/**\n * @template M\n * @param {?} moduleFactory\n * @return {?}\n */\nbootstrapModuleFactory<M>(moduleFactory: NgModuleFactory<M>): Promise<NgModuleRef<M>> {\n return this._bootstrapModuleFactoryWithZone(moduleFactory);\n }\n/**\n * @template M\n * @param {?} moduleFactory\n * @param {?=} ngZone\n * @return {?}\n */\nprivate _bootstrapModuleFactoryWithZone<M>(moduleFactory: NgModuleFactory<M>, ngZone?: NgZone):\n Promise<NgModuleRef<M>> {\n // Note: We need to create the NgZone _before_ we instantiate the module,\n // as instantiating the module creates some providers eagerly.\n // So we create a mini parent injector that just contains the new NgZone and\n // pass that as parent to the NgModuleFactory.\n if (!ngZone) ngZone = new NgZone({enableLongStackTrace: isDevMode()});\n // Attention: Don't use ApplicationRef.run here,\n // as we want to be sure that all possible constructor calls are inside `ngZone.run`!\n return ngZone.run(() => {\n const /** @type {?} */ ngZoneInjector =\n ReflectiveInjector.resolveAndCreate([{provide: NgZone, useValue: ngZone}], this.injector);\n const /** @type {?} */ moduleRef = /** @type {?} */(( <NgModuleInjector<M>>moduleFactory.create(ngZoneInjector)));\n const /** @type {?} */ exceptionHandler: ErrorHandler = moduleRef.injector.get(ErrorHandler, null);\n if (!exceptionHandler) {\n throw new Error('No ErrorHandler. Is platform module (BrowserModule) included?');\n }\n moduleRef.onDestroy(() => remove(this._modules, moduleRef)); /** @type {?} */((\n ngZone)).onError.subscribe({next: (error: any) => { exceptionHandler.handleError(error); }});\n return _callAndReportToErrorHandler(exceptionHandler, () => {\n const /** @type {?} */ initStatus: ApplicationInitStatus = moduleRef.injector.get(ApplicationInitStatus);\n return initStatus.donePromise.then(() => {\n this._moduleDoBootstrap(moduleRef);\n return moduleRef;\n });\n });\n });\n }\n/**\n * @template M\n * @param {?} moduleType\n * @param {?=} compilerOptions\n * @return {?}\n */\nbootstrapModule<M>(moduleType: Type<M>, compilerOptions: CompilerOptions|CompilerOptions[] = []):\n Promise<NgModuleRef<M>> {\n return this._bootstrapModuleWithZone(moduleType, compilerOptions);\n }\n/**\n * @template M\n * @param {?} moduleType\n * @param {?=} compilerOptions\n * @param {?=} ngZone\n * @return {?}\n */\nprivate _bootstrapModuleWithZone<M>(\n moduleType: Type<M>, compilerOptions: CompilerOptions|CompilerOptions[] = [],\n ngZone?: NgZone): Promise<NgModuleRef<M>> {\n const /** @type {?} */ compilerFactory: CompilerFactory = this.injector.get(CompilerFactory);\n const /** @type {?} */ compiler = compilerFactory.createCompiler(\n Array.isArray(compilerOptions) ? compilerOptions : [compilerOptions]);\n\n return compiler.compileModuleAsync(moduleType)\n .then((moduleFactory) => this._bootstrapModuleFactoryWithZone(moduleFactory, ngZone));\n }\n/**\n * @param {?} moduleRef\n * @return {?}\n */\nprivate _moduleDoBootstrap(moduleRef: NgModuleInjector<any>): void {\n const /** @type {?} */ appRef = moduleRef.injector.get(ApplicationRef);\n if (moduleRef.bootstrapFactories.length > 0) {\n moduleRef.bootstrapFactories.forEach(f => appRef.bootstrap(f));\n } else if (moduleRef.instance.ngDoBootstrap) {\n moduleRef.instance.ngDoBootstrap(appRef);\n } else {\n throw new Error(\n `The module ${stringify(moduleRef.instance.constructor)} was bootstrapped, but it does not declare \"@NgModule.bootstrap\" components nor a \"ngDoBootstrap\" method. ` +\n `Please define one of these.`);\n }\n this._modules.push(moduleRef);\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 PlatformRef__tsickle_Closure_declarations() {\n/** @type {?} */\nPlatformRef_.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nPlatformRef_.ctorParameters;\n/** @type {?} */\nPlatformRef_.prototype._modules;\n/** @type {?} */\nPlatformRef_.prototype._destroyListeners;\n/** @type {?} */\nPlatformRef_.prototype._destroyed;\n/** @type {?} */\nPlatformRef_.prototype._injector;\n}\n\n/**\n * A reference to an Angular application running on a page.\n * \n * \\@stable\n * @abstract\n */\nexport abstract class ApplicationRef {\n/**\n * Bootstrap a new component at the root level of the application.\n * \n * ### Bootstrap process\n * \n * When bootstrapping a new root component into an application, Angular mounts the\n * specified application component onto DOM elements identified by the [componentType]'s\n * selector and kicks off automatic change detection to finish initializing the component.\n * \n * ### Example\n * {\\@example core/ts/platform/platform.ts region='longform'}\n * @abstract\n * @template C\n * @param {?} componentFactory\n * @return {?}\n */\nbootstrap<C>(componentFactory: ComponentFactory<C>|Type<C>) {}\n/**\n * Invoke this method to explicitly process change detection and its side-effects.\n * \n * In development mode, `tick()` also performs a second change detection cycle to ensure that no\n * further changes are detected. If additional changes are picked up during this second cycle,\n * bindings in the app have side-effects that cannot be resolved in a single change detection\n * pass.\n * In this case, Angular throws an error, since an Angular application can only have one change\n * detection pass during which all change detection must complete.\n * @abstract\n * @return {?}\n */\ntick() {}\n/**\n * Get a list of component types registered to this application.\n * This list is populated even before the component is created.\n * @abstract\n * @return {?}\n */\ncomponentTypes() {}\n/**\n * Get a list of components registered to this application.\n * @abstract\n * @return {?}\n */\ncomponents() {}\n/**\n * Attaches a view so that it will be dirty checked.\n * The view will be automatically detached when it is destroyed.\n * This will throw if the view is already attached to a ViewContainer.\n * @abstract\n * @param {?} view\n * @return {?}\n */\nattachView(view: ViewRef) {}\n/**\n * Detaches a view from dirty checking again.\n * @abstract\n * @param {?} view\n * @return {?}\n */\ndetachView(view: ViewRef) {}\n/**\n * Returns the number of attached views.\n * @abstract\n * @return {?}\n */\nviewCount() {}\n/**\n * Returns an Observable that indicates when the application is stable or unstable.\n * @abstract\n * @return {?}\n */\nisStable() {}\n}\n/**\n * workaround https://github.com/angular/tsickle/issues/350\n * @suppress {checkTypes}\n */\nexport class ApplicationRef_ extends ApplicationRef {\n/**\n * \\@internal\n */\nstatic _tickScope: WtfScopeFn = wtfCreateScope('ApplicationRef#tick()');\nprivate _bootstrapListeners: ((compRef: ComponentRef<any>) => void)[] = [];\nprivate _rootComponents: ComponentRef<any>[] = [];\nprivate _rootComponentTypes: Type<any>[] = [];\nprivate _views: InternalViewRef[] = [];\nprivate _runningTick: boolean = false;\nprivate _enforceNoNewChanges: boolean = false;\nprivate _isStable: Observable<boolean>;\nprivate _stable = true;\n/**\n * @param {?} _zone\n * @param {?} _console\n * @param {?} _injector\n * @param {?} _exceptionHandler\n * @param {?} _componentFactoryResolver\n * @param {?} _initStatus\n */\nconstructor(\nprivate _zone: NgZone,\nprivate _console: Console,\nprivate _injector: Injector,\nprivate _exceptionHandler: ErrorHandler,\nprivate _componentFactoryResolver: ComponentFactoryResolver,\nprivate _initStatus: ApplicationInitStatus) {\n super();\n this._enforceNoNewChanges = isDevMode();\n\n this._zone.onMicrotaskEmpty.subscribe(\n {next: () => { this._zone.run(() => { this.tick(); }); }});\n\n const isCurrentlyStable = new Observable<boolean>((observer: Observer<boolean>) => {\n this._stable = this._zone.isStable && !this._zone.hasPendingMacrotasks &&\n !this._zone.hasPendingMicrotasks;\n this._zone.runOutsideAngular(() => {\n observer.next(this._stable);\n observer.complete();\n });\n });\n\n const isStable = new Observable<boolean>((observer: Observer<boolean>) => {\n const stableSub: Subscription = this._zone.onStable.subscribe(() => {\n NgZone.assertNotInAngularZone();\n\n // Check whether there are no pending macro/micro tasks in the next tick\n // to allow for NgZone to update the state.\n scheduleMicroTask(() => {\n if (!this._stable && !this._zone.hasPendingMacrotasks &&\n !this._zone.hasPendingMicrotasks) {\n this._stable = true;\n observer.next(true);\n }\n });\n });\n\n const unstableSub: Subscription = this._zone.onUnstable.subscribe(() => {\n NgZone.assertInAngularZone();\n if (this._stable) {\n this._stable = false;\n this._zone.runOutsideAngular(() => { observer.next(false); });\n }\n });\n\n return () => {\n stableSub.unsubscribe();\n unstableSub.unsubscribe();\n };\n });\n\n this._isStable = merge(isCurrentlyStable, share.call(isStable));\n }\n/**\n * @param {?} viewRef\n * @return {?}\n */\nattachView(viewRef: ViewRef): void {\n const /** @type {?} */ view = ( /** @type {?} */((viewRef as InternalViewRef)));\n this._views.push(view);\n view.attachToAppRef(this);\n }\n/**\n * @param {?} viewRef\n * @return {?}\n */\ndetachView(viewRef: ViewRef): void {\n const /** @type {?} */ view = ( /** @type {?} */((viewRef as InternalViewRef)));\n remove(this._views, view);\n view.detachFromAppRef();\n }\n/**\n * @template C\n * @param {?} componentOrFactory\n * @return {?}\n */\nbootstrap<C>(componentOrFactory: ComponentFactory<C>|Type<C>): ComponentRef<C> {\n if (!this._initStatus.done) {\n throw new Error(\n 'Cannot bootstrap as there are still asynchronous initializers running. Bootstrap components in the `ngDoBootstrap` method of the root module.');\n }\n let /** @type {?} */ componentFactory: ComponentFactory<C>;\n if (componentOrFactory instanceof ComponentFactory) {\n componentFactory = componentOrFactory;\n } else {\n componentFactory = /** @type {?} */((\n this._componentFactoryResolver.resolveComponentFactory(componentOrFactory)));\n }\n this._rootComponentTypes.push(componentFactory.componentType);\n\n // Create a factory associated with the current module if it's not bound to some other\n const /** @type {?} */ ngModule = componentFactory instanceof ComponentFactoryBoundToModule ?\n null :\n this._injector.get(NgModuleRef);\n const /** @type {?} */ compRef = componentFactory.create(Injector.NULL, [], componentFactory.selector, ngModule);\n\n compRef.onDestroy(() => { this._unloadComponent(compRef); });\n const /** @type {?} */ testability = compRef.injector.get(Testability, null);\n if (testability) {\n compRef.injector.get(TestabilityRegistry)\n .registerApplication(compRef.location.nativeElement, testability);\n }\n\n this._loadComponent(compRef);\n if (isDevMode()) {\n this._console.log(\n `Angular is running in the development mode. Call enableProdMode() to enable the production mode.`);\n }\n return compRef;\n }\n/**\n * @param {?} componentRef\n * @return {?}\n */\nprivate _loadComponent(componentRef: ComponentRef<any>): void {\n this.attachView(componentRef.hostView);\n this.tick();\n this._rootComponents.push(componentRef);\n // Get the listeners lazily to prevent DI cycles.\n const /** @type {?} */ listeners =\n this._injector.get(APP_BOOTSTRAP_LISTENER, []).concat(this._bootstrapListeners);\n listeners.forEach((listener) => listener(componentRef));\n }\n/**\n * @param {?} componentRef\n * @return {?}\n */\nprivate _unloadComponent(componentRef: ComponentRef<any>): void {\n this.detachView(componentRef.hostView);\n remove(this._rootComponents, componentRef);\n }\n/**\n * @return {?}\n */\ntick(): void {\n if (this._runningTick) {\n throw new Error('ApplicationRef.tick is called recursively');\n }\n\n const /** @type {?} */ scope = ApplicationRef_._tickScope();\n try {\n this._runningTick = true;\n this._views.forEach((view) => view.detectChanges());\n if (this._enforceNoNewChanges) {\n this._views.forEach((view) => view.checkNoChanges());\n }\n } catch ( /** @type {?} */e) {\n // Attention: Don't rethrow as it could cancel subscriptions to Observables!\n this._exceptionHandler.handleError(e);\n } finally {\n this._runningTick = false;\n wtfLeave(scope);\n }\n }\n/**\n * @return {?}\n */\nngOnDestroy() {\n // TODO(alxhub): Dispose of the NgZone.\n this._views.slice().forEach((view) => view.destroy());\n }\n/**\n * @return {?}\n */\nget viewCount() { return this._views.length; }\n/**\n * @return {?}\n */\nget componentTypes(): Type<any>[] { return this._rootComponentTypes; }\n/**\n * @return {?}\n */\nget components(): ComponentRef<any>[] { return this._rootComponents; }\n/**\n * @return {?}\n */\nget isStable(): Observable<boolean> { return this._isStable; }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: NgZone, },\n{type: Console, },\n{type: Injector, },\n{type: ErrorHandler, },\n{type: ComponentFactoryResolver, },\n{type: ApplicationInitStatus, },\n];\n}\n\nfunction ApplicationRef__tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\nApplicationRef_._tickScope;\n/** @type {?} */\nApplicationRef_.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nApplicationRef_.ctorParameters;\n/** @type {?} */\nApplicationRef_.prototype._bootstrapListeners;\n/** @type {?} */\nApplicationRef_.prototype._rootComponents;\n/** @type {?} */\nApplicationRef_.prototype._rootComponentTypes;\n/** @type {?} */\nApplicationRef_.prototype._views;\n/** @type {?} */\nApplicationRef_.prototype._runningTick;\n/** @type {?} */\nApplicationRef_.prototype._enforceNoNewChanges;\n/** @type {?} */\nApplicationRef_.prototype._isStable;\n/** @type {?} */\nApplicationRef_.prototype._stable;\n/** @type {?} */\nApplicationRef_.prototype._zone;\n/** @type {?} */\nApplicationRef_.prototype._console;\n/** @type {?} */\nApplicationRef_.prototype._injector;\n/** @type {?} */\nApplicationRef_.prototype._exceptionHandler;\n/** @type {?} */\nApplicationRef_.prototype._componentFactoryResolver;\n/** @type {?} */\nApplicationRef_.prototype._initStatus;\n}\n\n/**\n * @template T\n * @param {?} list\n * @param {?} el\n * @return {?}\n */\nfunction remove<T>(list: T[], el: T): void {\n const /** @type {?} */ index = list.indexOf(el);\n if (index > -1) {\n list.splice(index, 1);\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 {Injectable} from './di';\nexport class Console {\n/**\n * @param {?} message\n * @return {?}\n */\nlog(message: string): void {\n // tslint:disable-next-line:no-console\n console.log(message);\n }\n/**\n * @param {?} message\n * @return {?}\n */\nwarn(message: string): void {\n // tslint:disable-next-line:no-console\n console.warn(message);\n }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n];\n}\n\nfunction Console_tsickle_Closure_declarations() {\n/** @type {?} */\nConsole.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nConsole.ctorParameters;\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 {ERROR_ORIGINAL_ERROR, getDebugContext, getErrorLogger, getOriginalError} from './errors';\n/**\n * \\@whatItDoes Provides a hook for centralized exception handling.\n * \n * \\@description \n * \n * The default implementation of `ErrorHandler` prints error messages to the `console`. To\n * intercept error handling, write a custom exception handler that replaces this default as\n * appropriate for your app.\n * \n * ### Example\n * \n * ```\n * class MyErrorHandler implements ErrorHandler {\n * handleError(error) {\n * // do something with the exception\n * }\n * }\n * \n * \\@NgModule({ \n * providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]\n * })\n * class MyModule {}\n * ```\n * \n * \\@stable\n */\nexport class ErrorHandler {\n/**\n * \\@internal\n */\n_console: Console = console;\n/**\n * @param {?=} deprecatedParameter\n */\nconstructor(\n /**\n * @deprecated since v4.0 parameter no longer has an effect, as ErrorHandler will never\n * rethrow.\n */\n deprecatedParameter?: boolean) {}\n/**\n * @param {?} error\n * @return {?}\n */\nhandleError(error: any): void {\n const /** @type {?} */ originalError = this._findOriginalError(error);\n const /** @type {?} */ context = this._findContext(error);\n // Note: Browser consoles show the place from where console.error was called.\n // We can use this to give users additional information about the error.\n const /** @type {?} */ errorLogger = getErrorLogger(error);\n\n errorLogger(this._console, `ERROR`, error);\n if (originalError) {\n errorLogger(this._console, `ORIGINAL ERROR`, originalError);\n }\n if (context) {\n errorLogger(this._console, 'ERROR CONTEXT', context);\n }\n }\n/**\n * \\@internal\n * @param {?} error\n * @return {?}\n */\n_findContext(error: any): any {\n if (error) {\n return getDebugContext(error) ? getDebugContext(error) :\n this._findContext(getOriginalError(error));\n }\n\n return null;\n }\n/**\n * \\@internal\n * @param {?} error\n * @return {?}\n */\n_findOriginalError(error: Error): any {\n let /** @type {?} */ e = getOriginalError(error);\n while (e && getOriginalError(e)) {\n e = getOriginalError(e);\n }\n\n return e;\n }\n}\n\nfunction ErrorHandler_tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\nErrorHandler.prototype._console;\n}\n\n/**\n * @param {?} message\n * @param {?} originalError\n * @return {?}\n */\nexport function wrappedError(message: string, originalError: any): Error {\n const /** @type {?} */ msg =\n `${message} caused by: ${originalError instanceof Error ? originalError.message: originalError }`;\n const /** @type {?} */ error = Error(msg);\n ( /** @type {?} */((error as any)))[ERROR_ORIGINAL_ERROR] = originalError;\n return error;\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 {stringify} from '../util';\nimport {resolveForwardRef} from './forward_ref';\n/**\n * A unique object used for retrieving items from the {\\@link ReflectiveInjector}.\n * \n * Keys have:\n * - a system-wide unique `id`.\n * - a `token`.\n * \n * `Key` is used internally by {\\@link ReflectiveInjector} because its system-wide unique `id` allows\n * the\n * injector to store created objects in a more efficient way.\n * \n * `Key` should not be created directly. {\\@link ReflectiveInjector} creates keys automatically when\n * resolving\n * providers.\n * \\@experimental\n */\nexport class ReflectiveKey {\n/**\n * Private\n * @param {?} token\n * @param {?} id\n */\nconstructor(public token: Object,\npublic id: number) {\n if (!token) {\n throw new Error('Token must be defined!');\n }\n }\n/**\n * Returns a stringified token.\n * @return {?}\n */\nget displayName(): string { return stringify(this.token); }\n/**\n * Retrieves a `Key` for a token.\n * @param {?} token\n * @return {?}\n */\nstatic get(token: Object): ReflectiveKey {\n return _globalKeyRegistry.get(resolveForwardRef(token));\n }\n/**\n * @return {?} the number of keys registered in the system.\n */\nstatic get numberOfKeys(): number { return _globalKeyRegistry.numberOfKeys; }\n}\n\nfunction ReflectiveKey_tsickle_Closure_declarations() {\n/** @type {?} */\nReflectiveKey.prototype.token;\n/** @type {?} */\nReflectiveKey.prototype.id;\n}\n\n/**\n * \\@internal\n */\nexport class KeyRegistry {\nprivate _allKeys = new Map<Object, ReflectiveKey>();\n/**\n * @param {?} token\n * @return {?}\n */\nget(token: Object): ReflectiveKey {\n if (token instanceof ReflectiveKey) return token;\n\n if (this._allKeys.has(token)) {\n return /** @type {?} */(( this._allKeys.get(token)));\n }\n\n const /** @type {?} */ newKey = new ReflectiveKey(token, ReflectiveKey.numberOfKeys);\n this._allKeys.set(token, newKey);\n return newKey;\n }\n/**\n * @return {?}\n */\nget numberOfKeys(): number { return this._allKeys.size; }\n}\n\nfunction KeyRegistry_tsickle_Closure_declarations() {\n/** @type {?} */\nKeyRegistry.prototype._allKeys;\n}\n\n\nconst /** @type {?} */ _globalKeyRegistry = new KeyRegistry();\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, isType} from '../type';\nimport {global, stringify} from '../util';\nimport {PlatformReflectionCapabilities} from './platform_reflection_capabilities';\nimport {GetterFn, MethodFn, SetterFn} from './types';\n\n/**\n * Attention: This regex has to hold even if the code is minified!\n */\nexport const /** @type {?} */ DELEGATE_CTOR = /^function\\s+\\S+\\(\\)\\s*{[\\s\\S]+\\.apply\\(this,\\s*arguments\\)/;\nexport class ReflectionCapabilities implements PlatformReflectionCapabilities {\nprivate _reflect: any;\n/**\n * @param {?=} reflect\n */\nconstructor(reflect?: any) { this._reflect = reflect || global['Reflect']; }\n/**\n * @return {?}\n */\nisReflectionEnabled(): boolean { return true; }\n/**\n * @template T\n * @param {?} t\n * @return {?}\n */\nfactory<T>(t: Type<T>): (args: any[]) => T { return (...args: any[]) => new t(...args); }\n/**\n * \\@internal\n * @param {?} paramTypes\n * @param {?} paramAnnotations\n * @return {?}\n */\n_zipTypesAndAnnotations(paramTypes: any[], paramAnnotations: any[]): any[][] {\n let /** @type {?} */ result: any[][];\n\n if (typeof paramTypes === 'undefined') {\n result = new Array(paramAnnotations.length);\n } else {\n result = new Array(paramTypes.length);\n }\n\n for (let /** @type {?} */ i = 0; i < result.length; i++) {\n // TS outputs Object for parameters without types, while Traceur omits\n // the annotations. For now we preserve the Traceur behavior to aid\n // migration, but this can be revisited.\n if (typeof paramTypes === 'undefined') {\n result[i] = [];\n } else if (paramTypes[i] != Object) {\n result[i] = [paramTypes[i]];\n } else {\n result[i] = [];\n }\n if (paramAnnotations && paramAnnotations[i] != null) {\n result[i] = result[i].concat(paramAnnotations[i]);\n }\n }\n return result;\n }\n/**\n * @param {?} type\n * @param {?} parentCtor\n * @return {?}\n */\nprivate _ownParameters(type: Type<any>, parentCtor: any): any[][]|null {\n // If we have no decorators, we only have function.length as metadata.\n // In that case, to detect whether a child class declared an own constructor or not,\n // we need to look inside of that constructor to check whether it is\n // just calling the parent.\n // This also helps to work around for https://github.com/Microsoft/TypeScript/issues/12439\n // that sets 'design:paramtypes' to []\n // if a class inherits from another class but has no ctor declared itself.\n if (DELEGATE_CTOR.exec(type.toString())) {\n return null;\n }\n\n // Prefer the direct API.\n if (( /** @type {?} */((<any>type))).parameters && ( /** @type {?} */((<any>type))).parameters !== parentCtor.parameters) {\n return ( /** @type {?} */((<any>type))).parameters;\n }\n\n // API of tsickle for lowering decorators to properties on the class.\n const /** @type {?} */ tsickleCtorParams = ( /** @type {?} */((<any>type))).ctorParameters;\n if (tsickleCtorParams && tsickleCtorParams !== parentCtor.ctorParameters) {\n // Newer tsickle uses a function closure\n // Retain the non-function case for compatibility with older tsickle\n const /** @type {?} */ ctorParameters =\n typeof tsickleCtorParams === 'function' ? tsickleCtorParams() : tsickleCtorParams;\n const /** @type {?} */ paramTypes = ctorParameters.map((ctorParam: any) => ctorParam && ctorParam.type);\n const /** @type {?} */ paramAnnotations = ctorParameters.map(\n (ctorParam: any) =>\n ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators));\n return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);\n }\n\n // API for metadata created by invoking the decorators.\n if (this._reflect != null && this._reflect.getOwnMetadata != null) {\n const /** @type {?} */ paramAnnotations = this._reflect.getOwnMetadata('parameters', type);\n const /** @type {?} */ paramTypes = this._reflect.getOwnMetadata('design:paramtypes', type);\n if (paramTypes || paramAnnotations) {\n return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);\n }\n }\n\n // If a class has no decorators, at least create metadata\n // based on function.length.\n // Note: We know that this is a real constructor as we checked\n // the content of the constructor above.\n return new Array(( /** @type {?} */((<any>type.length)))).fill(undefined);\n }\n/**\n * @param {?} type\n * @return {?}\n */\nparameters(type: Type<any>): any[][] {\n // Note: only report metadata if we have at least one class decorator\n // to stay in sync with the static reflector.\n if (!isType(type)) {\n return [];\n }\n const /** @type {?} */ parentCtor = getParentCtor(type);\n let /** @type {?} */ parameters = this._ownParameters(type, parentCtor);\n if (!parameters && parentCtor !== Object) {\n parameters = this.parameters(parentCtor);\n }\n return parameters || [];\n }\n/**\n * @param {?} typeOrFunc\n * @param {?} parentCtor\n * @return {?}\n */\nprivate _ownAnnotations(typeOrFunc: Type<any>, parentCtor: any): any[]|null {\n // Prefer the direct API.\n if (( /** @type {?} */((<any>typeOrFunc))).annotations && ( /** @type {?} */((<any>typeOrFunc))).annotations !== parentCtor.annotations) {\n let /** @type {?} */ annotations = ( /** @type {?} */((<any>typeOrFunc))).annotations;\n if (typeof annotations === 'function' && annotations.annotations) {\n annotations = annotations.annotations;\n }\n return annotations;\n }\n\n // API of tsickle for lowering decorators to properties on the class.\n if (( /** @type {?} */((<any>typeOrFunc))).decorators && ( /** @type {?} */((<any>typeOrFunc))).decorators !== parentCtor.decorators) {\n return convertTsickleDecoratorIntoMetadata(( /** @type {?} */((<any>typeOrFunc))).decorators);\n }\n\n // API for metadata created by invoking the decorators.\n if (this._reflect && this._reflect.getOwnMetadata) {\n return this._reflect.getOwnMetadata('annotations', typeOrFunc);\n }\n return null;\n }\n/**\n * @param {?} typeOrFunc\n * @return {?}\n */\nannotations(typeOrFunc: Type<any>): any[] {\n if (!isType(typeOrFunc)) {\n return [];\n }\n const /** @type {?} */ parentCtor = getParentCtor(typeOrFunc);\n const /** @type {?} */ ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];\n const /** @type {?} */ parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];\n return parentAnnotations.concat(ownAnnotations);\n }\n/**\n * @param {?} typeOrFunc\n * @param {?} parentCtor\n * @return {?}\n */\nprivate _ownPropMetadata(typeOrFunc: any, parentCtor: any): {[key: string]: any[]}|null {\n // Prefer the direct API.\n if (( /** @type {?} */((<any>typeOrFunc))).propMetadata &&\n ( /** @type {?} */((<any>typeOrFunc))).propMetadata !== parentCtor.propMetadata) {\n let /** @type {?} */ propMetadata = ( /** @type {?} */((<any>typeOrFunc))).propMetadata;\n if (typeof propMetadata === 'function' && propMetadata.propMetadata) {\n propMetadata = propMetadata.propMetadata;\n }\n return propMetadata;\n }\n\n // API of tsickle for lowering decorators to properties on the class.\n if (( /** @type {?} */((<any>typeOrFunc))).propDecorators &&\n ( /** @type {?} */((<any>typeOrFunc))).propDecorators !== parentCtor.propDecorators) {\n const /** @type {?} */ propDecorators = ( /** @type {?} */((<any>typeOrFunc))).propDecorators;\n const /** @type {?} */ propMetadata = /** @type {?} */(( <{[key: string]: any[]}>{}));\n Object.keys(propDecorators).forEach(prop => {\n propMetadata[prop] = convertTsickleDecoratorIntoMetadata(propDecorators[prop]);\n });\n return propMetadata;\n }\n\n // API for metadata created by invoking the decorators.\n if (this._reflect && this._reflect.getOwnMetadata) {\n return this._reflect.getOwnMetadata('propMetadata', typeOrFunc);\n }\n return null;\n }\n/**\n * @param {?} typeOrFunc\n * @return {?}\n */\npropMetadata(typeOrFunc: any): {[key: string]: any[]} {\n if (!isType(typeOrFunc)) {\n return {};\n }\n const /** @type {?} */ parentCtor = getParentCtor(typeOrFunc);\n const /** @type {?} */ propMetadata: {[key: string]: any[]} = {};\n if (parentCtor !== Object) {\n const /** @type {?} */ parentPropMetadata = this.propMetadata(parentCtor);\n Object.keys(parentPropMetadata).forEach((propName) => {\n propMetadata[propName] = parentPropMetadata[propName];\n });\n }\n const /** @type {?} */ ownPropMetadata = this._ownPropMetadata(typeOrFunc, parentCtor);\n if (ownPropMetadata) {\n Object.keys(ownPropMetadata).forEach((propName) => {\n const /** @type {?} */ decorators: any[] = [];\n if (propMetadata.hasOwnProperty(propName)) {\n decorators.push(...propMetadata[propName]);\n }\n decorators.push(...ownPropMetadata[propName]);\n propMetadata[propName] = decorators;\n });\n }\n return propMetadata;\n }\n/**\n * @param {?} type\n * @param {?} lcProperty\n * @return {?}\n */\nhasLifecycleHook(type: any, lcProperty: string): boolean {\n return type instanceof Type && lcProperty in type.prototype;\n }\n/**\n * @param {?} name\n * @return {?}\n */\ngetter(name: string): GetterFn { return /** @type {?} */(( <GetterFn>new Function('o', 'return o.' + name + ';'))); }\n/**\n * @param {?} name\n * @return {?}\n */\nsetter(name: string): SetterFn {\n return /** @type {?} */(( <SetterFn>new Function('o', 'v', 'return o.' + name + ' = v;')));\n }\n/**\n * @param {?} name\n * @return {?}\n */\nmethod(name: string): MethodFn {\n const /** @type {?} */ functionBody = `if (!o.${name}) throw new Error('\"${name}\" is undefined');\n return o.${name}.apply(o, args);`;\n return /** @type {?} */(( <MethodFn>new Function('o', 'args', functionBody)));\n }\n/**\n * @param {?} type\n * @return {?}\n */\nimportUri(type: any): string {\n // StaticSymbol\n if (typeof type === 'object' && type['filePath']) {\n return type['filePath'];\n }\n // Runtime type\n return `./${stringify(type)}`;\n }\n/**\n * @param {?} type\n * @return {?}\n */\nresourceUri(type: any): string { return `./${stringify(type)}`; }\n/**\n * @param {?} name\n * @param {?} moduleUrl\n * @param {?} members\n * @param {?} runtime\n * @return {?}\n */\nresolveIdentifier(name: string, moduleUrl: string, members: string[], runtime: any): any {\n return runtime;\n }\n/**\n * @param {?} enumIdentifier\n * @param {?} name\n * @return {?}\n */\nresolveEnum(enumIdentifier: any, name: string): any { return enumIdentifier[name]; }\n}\n\nfunction ReflectionCapabilities_tsickle_Closure_declarations() {\n/** @type {?} */\nReflectionCapabilities.prototype._reflect;\n}\n\n/**\n * @param {?} decoratorInvocations\n * @return {?}\n */\nfunction convertTsickleDecoratorIntoMetadata(decoratorInvocations: any[]): any[] {\n if (!decoratorInvocations) {\n return [];\n }\n return decoratorInvocations.map(decoratorInvocation => {\n const /** @type {?} */ decoratorType = decoratorInvocation.type;\n const /** @type {?} */ annotationCls = decoratorType.annotationCls;\n const /** @type {?} */ annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];\n return new annotationCls(...annotationArgs);\n });\n}\n/**\n * @param {?} ctor\n * @return {?}\n */\nfunction getParentCtor(ctor: Function): Type<any> {\n const /** @type {?} */ parentProto = Object.getPrototypeOf(ctor.prototype);\n const /** @type {?} */ parentCtor = parentProto ? parentProto.constructor : null;\n // Note: We always use `Object` as the null value\n // to simplify checking later on.\n return parentCtor || Object;\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 '../type';\nimport {PlatformReflectionCapabilities} from './platform_reflection_capabilities';\nimport {ReflectorReader} from './reflector_reader';\nimport {GetterFn, MethodFn, SetterFn} from './types';\n\nexport {PlatformReflectionCapabilities} from './platform_reflection_capabilities';\nexport {GetterFn, MethodFn, SetterFn} from './types';\n/**\n * Provides access to reflection data about symbols. Used internally by Angular\n * to power dependency injection and compilation.\n */\nexport class Reflector extends ReflectorReader {\n/**\n * @param {?} reflectionCapabilities\n */\nconstructor(public reflectionCapabilities: PlatformReflectionCapabilities) { super(); }\n/**\n * @param {?} caps\n * @return {?}\n */\nupdateCapabilities(caps: PlatformReflectionCapabilities) { this.reflectionCapabilities = caps; }\n/**\n * @param {?} type\n * @return {?}\n */\nfactory(type: Type<any>): Function { return this.reflectionCapabilities.factory(type); }\n/**\n * @param {?} typeOrFunc\n * @return {?}\n */\nparameters(typeOrFunc: Type<any>): any[][] {\n return this.reflectionCapabilities.parameters(typeOrFunc);\n }\n/**\n * @param {?} typeOrFunc\n * @return {?}\n */\nannotations(typeOrFunc: Type<any>): any[] {\n return this.reflectionCapabilities.annotations(typeOrFunc);\n }\n/**\n * @param {?} typeOrFunc\n * @return {?}\n */\npropMetadata(typeOrFunc: Type<any>): {[key: string]: any[]} {\n return this.reflectionCapabilities.propMetadata(typeOrFunc);\n }\n/**\n * @param {?} type\n * @param {?} lcProperty\n * @return {?}\n */\nhasLifecycleHook(type: any, lcProperty: string): boolean {\n return this.reflectionCapabilities.hasLifecycleHook(type, lcProperty);\n }\n/**\n * @param {?} name\n * @return {?}\n */\ngetter(name: string): GetterFn { return this.reflectionCapabilities.getter(name); }\n/**\n * @param {?} name\n * @return {?}\n */\nsetter(name: string): SetterFn { return this.reflectionCapabilities.setter(name); }\n/**\n * @param {?} name\n * @return {?}\n */\nmethod(name: string): MethodFn { return this.reflectionCapabilities.method(name); }\n/**\n * @param {?} type\n * @return {?}\n */\nimportUri(type: any): string { return this.reflectionCapabilities.importUri(type); }\n/**\n * @param {?} type\n * @return {?}\n */\nresourceUri(type: any): string { return this.reflectionCapabilities.resourceUri(type); }\n/**\n * @param {?} name\n * @param {?} moduleUrl\n * @param {?} members\n * @param {?} runtime\n * @return {?}\n */\nresolveIdentifier(name: string, moduleUrl: string, members: string[]|null, runtime: any): any {\n return this.reflectionCapabilities.resolveIdentifier(name, moduleUrl, members, runtime);\n }\n/**\n * @param {?} identifier\n * @param {?} name\n * @return {?}\n */\nresolveEnum(identifier: any, name: string): any {\n return this.reflectionCapabilities.resolveEnum(identifier, name);\n }\n}\n\nfunction Reflector_tsickle_Closure_declarations() {\n/** @type {?} */\nReflector.prototype.reflectionCapabilities;\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 {reflector} from '../reflection/reflection';\nimport {Type} from '../type';\n\nimport {resolveForwardRef} from './forward_ref';\nimport {InjectionToken} from './injection_token';\nimport {Inject, Optional, Self, SkipSelf} from './metadata';\nimport {ClassProvider, ExistingProvider, FactoryProvider, Provider, TypeProvider, ValueProvider} from './provider';\nimport {invalidProviderError, mixingMultiProvidersWithRegularProvidersError, noAnnotationError} from './reflective_errors';\nimport {ReflectiveKey} from './reflective_key';\n\n\ninterface NormalizedProvider extends TypeProvider, ValueProvider, ClassProvider, ExistingProvider,\n FactoryProvider {}\n/**\n * `Dependency` is used by the framework to extend DI.\n * This is internal to Angular and should not be used directly.\n */\nexport class ReflectiveDependency {\n/**\n * @param {?} key\n * @param {?} optional\n * @param {?} visibility\n */\nconstructor(\npublic key: ReflectiveKey,\npublic optional: boolean,\npublic visibility: Self|SkipSelf|null) {}\n/**\n * @param {?} key\n * @return {?}\n */\nstatic fromKey(key: ReflectiveKey): ReflectiveDependency {\n return new ReflectiveDependency(key, false, null);\n }\n}\n\nfunction ReflectiveDependency_tsickle_Closure_declarations() {\n/** @type {?} */\nReflectiveDependency.prototype.key;\n/** @type {?} */\nReflectiveDependency.prototype.optional;\n/** @type {?} */\nReflectiveDependency.prototype.visibility;\n}\n\n\nconst /** @type {?} */ _EMPTY_LIST: any[] = [];\n\n/**\n * An internal resolved representation of a {@link Provider} used by the {@link Injector}.\n *\n * It is usually created automatically by `Injector.resolveAndCreate`.\n *\n * It can be created manually, as follows:\n *\n * ### Example ([live demo](http://plnkr.co/edit/RfEnhh8kUEI0G3qsnIeT?p%3Dpreview&p=preview))\n *\n * ```typescript\n * var resolvedProviders = Injector.resolve([{ provide: 'message', useValue: 'Hello' }]);\n * var injector = Injector.fromResolvedProviders(resolvedProviders);\n *\n * expect(injector.get('message')).toEqual('Hello');\n * ```\n *\n * @experimental\n */\nexport interface ResolvedReflectiveProvider {\n /**\n * A key, usually a `Type<any>`.\n */\n key: ReflectiveKey;\n\n /**\n * Factory function which can return an instance of an object represented by a key.\n */\n resolvedFactories: ResolvedReflectiveFactory[];\n\n /**\n * Indicates if the provider is a multi-provider or a regular provider.\n */\n multiProvider: boolean;\n}\nexport class ResolvedReflectiveProvider_ implements ResolvedReflectiveProvider {\n/**\n * @param {?} key\n * @param {?} resolvedFactories\n * @param {?} multiProvider\n */\nconstructor(\npublic key: ReflectiveKey,\npublic resolvedFactories: ResolvedReflectiveFactory[],\npublic multiProvider: boolean) {}\n/**\n * @return {?}\n */\nget resolvedFactory(): ResolvedReflectiveFactory { return this.resolvedFactories[0]; }\n}\n\nfunction ResolvedReflectiveProvider__tsickle_Closure_declarations() {\n/** @type {?} */\nResolvedReflectiveProvider_.prototype.key;\n/** @type {?} */\nResolvedReflectiveProvider_.prototype.resolvedFactories;\n/** @type {?} */\nResolvedReflectiveProvider_.prototype.multiProvider;\n}\n\n/**\n * An internal resolved representation of a factory function created by resolving {\\@link\n * Provider}.\n * \\@experimental\n */\nexport class ResolvedReflectiveFactory {\n/**\n * @param {?} factory\n * @param {?} dependencies\n */\nconstructor(\npublic factory: Function,\npublic dependencies: ReflectiveDependency[]) {}\n}\n\nfunction ResolvedReflectiveFactory_tsickle_Closure_declarations() {\n/**\n * Factory function which can return an instance of an object represented by a key.\n * @type {?}\n */\nResolvedReflectiveFactory.prototype.factory;\n/**\n * Arguments (dependencies) to the `factory` function.\n * @type {?}\n */\nResolvedReflectiveFactory.prototype.dependencies;\n}\n\n/**\n * Resolve a single provider.\n * @param {?} provider\n * @return {?}\n */\nfunction resolveReflectiveFactory(provider: NormalizedProvider): ResolvedReflectiveFactory {\n let /** @type {?} */ factoryFn: Function;\n let /** @type {?} */ resolvedDeps: ReflectiveDependency[];\n if (provider.useClass) {\n const /** @type {?} */ useClass = resolveForwardRef(provider.useClass);\n factoryFn = reflector.factory(useClass);\n resolvedDeps = _dependenciesFor(useClass);\n } else if (provider.useExisting) {\n factoryFn = (aliasInstance: any) => aliasInstance;\n resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];\n } else if (provider.useFactory) {\n factoryFn = provider.useFactory;\n resolvedDeps = constructDependencies(provider.useFactory, provider.deps);\n } else {\n factoryFn = () => provider.useValue;\n resolvedDeps = _EMPTY_LIST;\n }\n return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);\n}\n/**\n * Converts the {\\@link Provider} into {\\@link ResolvedProvider}.\n * \n * {\\@link Injector} internally only uses {\\@link ResolvedProvider}, {\\@link Provider} contains\n * convenience provider syntax.\n * @param {?} provider\n * @return {?}\n */\nfunction resolveReflectiveProvider(provider: NormalizedProvider): ResolvedReflectiveProvider {\n return new ResolvedReflectiveProvider_(\n ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)],\n provider.multi || false);\n}\n/**\n * Resolve a list of Providers.\n * @param {?} providers\n * @return {?}\n */\nexport function resolveReflectiveProviders(providers: Provider[]): ResolvedReflectiveProvider[] {\n const /** @type {?} */ normalized = _normalizeProviders(providers, []);\n const /** @type {?} */ resolved = normalized.map(resolveReflectiveProvider);\n const /** @type {?} */ resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map());\n return Array.from(resolvedProviderMap.values());\n}\n/**\n * Merges a list of ResolvedProviders into a list where\n * each key is contained exactly once and multi providers\n * have been merged.\n * @param {?} providers\n * @param {?} normalizedProvidersMap\n * @return {?}\n */\nexport function mergeResolvedReflectiveProviders(\n providers: ResolvedReflectiveProvider[],\n normalizedProvidersMap: Map<number, ResolvedReflectiveProvider>):\n Map<number, ResolvedReflectiveProvider> {\n for (let /** @type {?} */ i = 0; i < providers.length; i++) {\n const /** @type {?} */ provider = providers[i];\n const /** @type {?} */ existing = normalizedProvidersMap.get(provider.key.id);\n if (existing) {\n if (provider.multiProvider !== existing.multiProvider) {\n throw mixingMultiProvidersWithRegularProvidersError(existing, provider);\n }\n if (provider.multiProvider) {\n for (let /** @type {?} */ j = 0; j < provider.resolvedFactories.length; j++) {\n existing.resolvedFactories.push(provider.resolvedFactories[j]);\n }\n } else {\n normalizedProvidersMap.set(provider.key.id, provider);\n }\n } else {\n let /** @type {?} */ resolvedProvider: ResolvedReflectiveProvider;\n if (provider.multiProvider) {\n resolvedProvider = new ResolvedReflectiveProvider_(\n provider.key, provider.resolvedFactories.slice(), provider.multiProvider);\n } else {\n resolvedProvider = provider;\n }\n normalizedProvidersMap.set(provider.key.id, resolvedProvider);\n }\n }\n return normalizedProvidersMap;\n}\n/**\n * @param {?} providers\n * @param {?} res\n * @return {?}\n */\nfunction _normalizeProviders(providers: Provider[], res: Provider[]): Provider[] {\n providers.forEach(b => {\n if (b instanceof Type) {\n res.push({provide: b, useClass: b});\n\n } else if (b && typeof b == 'object' && ( /** @type {?} */((b as any))).provide !== undefined) {\n res.push( /** @type {?} */((b as NormalizedProvider)));\n\n } else if (b instanceof Array) {\n _normalizeProviders(b, res);\n\n } else {\n throw invalidProviderError(b);\n }\n });\n\n return res;\n}\n/**\n * @param {?} typeOrFunc\n * @param {?=} dependencies\n * @return {?}\n */\nexport function constructDependencies(\n typeOrFunc: any, dependencies?: any[]): ReflectiveDependency[] {\n if (!dependencies) {\n return _dependenciesFor(typeOrFunc);\n } else {\n const /** @type {?} */ params: any[][] = dependencies.map(t => [t]);\n return dependencies.map(t => _extractToken(typeOrFunc, t, params));\n }\n}\n/**\n * @param {?} typeOrFunc\n * @return {?}\n */\nfunction _dependenciesFor(typeOrFunc: any): ReflectiveDependency[] {\n const /** @type {?} */ params = reflector.parameters(typeOrFunc);\n\n if (!params) return [];\n if (params.some(p => p == null)) {\n throw noAnnotationError(typeOrFunc, params);\n }\n return params.map(p => _extractToken(typeOrFunc, p, params));\n}\n/**\n * @param {?} typeOrFunc\n * @param {?} metadata\n * @param {?} params\n * @return {?}\n */\nfunction _extractToken(\n typeOrFunc: any, metadata: any[] | any, params: any[][]): ReflectiveDependency {\n let /** @type {?} */ token: any = null;\n let /** @type {?} */ optional = false;\n\n if (!Array.isArray(metadata)) {\n if (metadata instanceof Inject) {\n return _createDependency(metadata['token'], optional, null);\n } else {\n return _createDependency(metadata, optional, null);\n }\n }\n\n let /** @type {?} */ visibility: Self|SkipSelf|null = null;\n\n for (let /** @type {?} */ i = 0; i < metadata.length; ++i) {\n const /** @type {?} */ paramMetadata = metadata[i];\n\n if (paramMetadata instanceof Type) {\n token = paramMetadata;\n\n } else if (paramMetadata instanceof Inject) {\n token = paramMetadata['token'];\n\n } else if (paramMetadata instanceof Optional) {\n optional = true;\n\n } else if (paramMetadata instanceof Self || paramMetadata instanceof SkipSelf) {\n visibility = paramMetadata;\n } else if (paramMetadata instanceof InjectionToken) {\n token = paramMetadata;\n }\n }\n\n token = resolveForwardRef(token);\n\n if (token != null) {\n return _createDependency(token, optional, visibility);\n } else {\n throw noAnnotationError(typeOrFunc, params);\n }\n}\n/**\n * @param {?} token\n * @param {?} optional\n * @param {?} visibility\n * @return {?}\n */\nfunction _createDependency(\n token: any, optional: boolean, visibility: Self | SkipSelf | null): ReflectiveDependency {\n return new ReflectiveDependency(ReflectiveKey.get(token), optional, visibility);\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, THROW_IF_NOT_FOUND} from './injector';\nimport {Self, SkipSelf} from './metadata';\nimport {Provider} from './provider';\nimport {cyclicDependencyError, instantiationError, noProviderError, outOfBoundsError} from './reflective_errors';\nimport {ReflectiveKey} from './reflective_key';\nimport {ReflectiveDependency, ResolvedReflectiveFactory, ResolvedReflectiveProvider, resolveReflectiveProviders} from './reflective_provider';\n\n// Threshold for the dynamic version\nconst /** @type {?} */ UNDEFINED = new Object();\n/**\n * A ReflectiveDependency injection container used for instantiating objects and resolving\n * dependencies.\n * \n * An `Injector` is a replacement for a `new` operator, which can automatically resolve the\n * constructor dependencies.\n * \n * In typical use, application code asks for the dependencies in the constructor and they are\n * resolved by the `Injector`.\n * \n * ### Example ([live demo](http://plnkr.co/edit/jzjec0?p=preview))\n * \n * The following example creates an `Injector` configured to create `Engine` and `Car`.\n * \n * ```typescript\n * \\@Injectable() \n * class Engine {\n * }\n * \n * \\@Injectable() \n * class Car {\n * constructor(public engine:Engine) {}\n * }\n * \n * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);\n * var car = injector.get(Car);\n * expect(car instanceof Car).toBe(true);\n * expect(car.engine instanceof Engine).toBe(true);\n * ```\n * \n * Notice, we don't use the `new` operator because we explicitly want to have the `Injector`\n * resolve all of the object's dependencies automatically.\n * \n * \\@stable\n * @abstract\n */\nexport abstract class ReflectiveInjector implements Injector {\n/**\n * Turns an array of provider definitions into an array of resolved providers.\n * \n * A resolution is a process of flattening multiple nested arrays and converting individual\n * providers into an array of {\\@link ResolvedReflectiveProvider}s.\n * \n * ### Example ([live demo](http://plnkr.co/edit/AiXTHi?p=preview))\n * \n * ```typescript\n * \\@Injectable() \n * class Engine {\n * }\n * \n * \\@Injectable() \n * class Car {\n * constructor(public engine:Engine) {}\n * }\n * \n * var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);\n * \n * expect(providers.length).toEqual(2);\n * \n * expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);\n * expect(providers[0].key.displayName).toBe(\"Car\");\n * expect(providers[0].dependencies.length).toEqual(1);\n * expect(providers[0].factory).toBeDefined();\n * \n * expect(providers[1].key.displayName).toBe(\"Engine\");\n * });\n * ```\n * \n * See {\\@link ReflectiveInjector#fromResolvedProviders} for more info.\n * @param {?} providers\n * @return {?}\n */\nstatic resolve(providers: Provider[]): ResolvedReflectiveProvider[] {\n return resolveReflectiveProviders(providers);\n }\n/**\n * Resolves an array of providers and creates an injector from those providers.\n * \n * The passed-in providers can be an array of `Type`, {\\@link Provider},\n * or a recursive array of more providers.\n * \n * ### Example ([live demo](http://plnkr.co/edit/ePOccA?p=preview))\n * \n * ```typescript\n * \\@Injectable() \n * class Engine {\n * }\n * \n * \\@Injectable() \n * class Car {\n * constructor(public engine:Engine) {}\n * }\n * \n * var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);\n * expect(injector.get(Car) instanceof Car).toBe(true);\n * ```\n * \n * This function is slower than the corresponding `fromResolvedProviders`\n * because it needs to resolve the passed-in providers first.\n * See {\\@link Injector#resolve} and {\\@link Injector#fromResolvedProviders}.\n * @param {?} providers\n * @param {?=} parent\n * @return {?}\n */\nstatic resolveAndCreate(providers: Provider[], parent?: Injector): ReflectiveInjector {\n const /** @type {?} */ ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);\n return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);\n }\n/**\n * Creates an injector from previously resolved providers.\n * \n * This API is the recommended way to construct injectors in performance-sensitive parts.\n * \n * ### Example ([live demo](http://plnkr.co/edit/KrSMci?p=preview))\n * \n * ```typescript\n * \\@Injectable() \n * class Engine {\n * }\n * \n * \\@Injectable() \n * class Car {\n * constructor(public engine:Engine) {}\n * }\n * \n * var providers = ReflectiveInjector.resolve([Car, Engine]);\n * var injector = ReflectiveInjector.fromResolvedProviders(providers);\n * expect(injector.get(Car) instanceof Car).toBe(true);\n * ```\n * \\@experimental\n * @param {?} providers\n * @param {?=} parent\n * @return {?}\n */\nstatic fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent?: Injector):\n ReflectiveInjector {\n return new ReflectiveInjector_(providers, parent);\n }\n/**\n * Parent of this injector.\n * \n * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.\n * -->\n * \n * ### Example ([live demo](http://plnkr.co/edit/eosMGo?p=preview))\n * \n * ```typescript\n * var parent = ReflectiveInjector.resolveAndCreate([]);\n * var child = parent.resolveAndCreateChild([]);\n * expect(child.parent).toBe(parent);\n * ```\n * @abstract\n * @return {?}\n */\nparent() {}\n/**\n * Resolves an array of providers and creates a child injector from those providers.\n * \n * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.\n * -->\n * \n * The passed-in providers can be an array of `Type`, {\\@link Provider},\n * or a recursive array of more providers.\n * \n * ### Example ([live demo](http://plnkr.co/edit/opB3T4?p=preview))\n * \n * ```typescript\n * class ParentProvider {}\n * class ChildProvider {}\n * \n * var parent = ReflectiveInjector.resolveAndCreate([ParentProvider]);\n * var child = parent.resolveAndCreateChild([ChildProvider]);\n * \n * expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);\n * expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);\n * expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));\n * ```\n * \n * This function is slower than the corresponding `createChildFromResolved`\n * because it needs to resolve the passed-in providers first.\n * See {\\@link Injector#resolve} and {\\@link Injector#createChildFromResolved}.\n * @abstract\n * @param {?} providers\n * @return {?}\n */\nresolveAndCreateChild(providers: Provider[]) {}\n/**\n * Creates a child injector from previously resolved providers.\n * \n * <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection.\n * -->\n * \n * This API is the recommended way to construct injectors in performance-sensitive parts.\n * \n * ### Example ([live demo](http://plnkr.co/edit/VhyfjN?p=preview))\n * \n * ```typescript\n * class ParentProvider {}\n * class ChildProvider {}\n * \n * var parentProviders = ReflectiveInjector.resolve([ParentProvider]);\n * var childProviders = ReflectiveInjector.resolve([ChildProvider]);\n * \n * var parent = ReflectiveInjector.fromResolvedProviders(parentProviders);\n * var child = parent.createChildFromResolved(childProviders);\n * \n * expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);\n * expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);\n * expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));\n * ```\n * @abstract\n * @param {?} providers\n * @return {?}\n */\ncreateChildFromResolved(providers: ResolvedReflectiveProvider[]) {}\n/**\n * Resolves a provider and instantiates an object in the context of the injector.\n * \n * The created object does not get cached by the injector.\n * \n * ### Example ([live demo](http://plnkr.co/edit/yvVXoB?p=preview))\n * \n * ```typescript\n * \\@Injectable() \n * class Engine {\n * }\n * \n * \\@Injectable() \n * class Car {\n * constructor(public engine:Engine) {}\n * }\n * \n * var injector = ReflectiveInjector.resolveAndCreate([Engine]);\n * \n * var car = injector.resolveAndInstantiate(Car);\n * expect(car.engine).toBe(injector.get(Engine));\n * expect(car).not.toBe(injector.resolveAndInstantiate(Car));\n * ```\n * @abstract\n * @param {?} provider\n * @return {?}\n */\nresolveAndInstantiate(provider: Provider) {}\n/**\n * Instantiates an object using a resolved provider in the context of the injector.\n * \n * The created object does not get cached by the injector.\n * \n * ### Example ([live demo](http://plnkr.co/edit/ptCImQ?p=preview))\n * \n * ```typescript\n * \\@Injectable() \n * class Engine {\n * }\n * \n * \\@Injectable() \n * class Car {\n * constructor(public engine:Engine) {}\n * }\n * \n * var injector = ReflectiveInjector.resolveAndCreate([Engine]);\n * var carProvider = ReflectiveInjector.resolve([Car])[0];\n * var car = injector.instantiateResolved(carProvider);\n * expect(car.engine).toBe(injector.get(Engine));\n * expect(car).not.toBe(injector.instantiateResolved(carProvider));\n * ```\n * @abstract\n * @param {?} provider\n * @return {?}\n */\ninstantiateResolved(provider: ResolvedReflectiveProvider) {}\n/**\n * @abstract\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\nget(token: any, notFoundValue?: any) {}\n}\nexport class ReflectiveInjector_ implements ReflectiveInjector {\n/**\n * \\@internal\n */\n_constructionCounter: number = 0;\n/**\n * \\@internal\n */\npublic _providers: ResolvedReflectiveProvider[];\n/**\n * \\@internal\n */\npublic _parent: Injector|null;\n\n keyIds: number[];\n objs: any[];\n/**\n * Private\n * @param {?} _providers\n * @param {?=} _parent\n */\nconstructor(_providers: ResolvedReflectiveProvider[], _parent?: Injector) {\n this._providers = _providers;\n this._parent = _parent || null;\n\n const len = _providers.length;\n\n this.keyIds = new Array(len);\n this.objs = new Array(len);\n\n for (let i = 0; i < len; i++) {\n this.keyIds[i] = _providers[i].key.id;\n this.objs[i] = UNDEFINED;\n }\n }\n/**\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\nget(token: any, notFoundValue: any = THROW_IF_NOT_FOUND): any {\n return this._getByKey(ReflectiveKey.get(token), null, notFoundValue);\n }\n/**\n * @return {?}\n */\nget parent(): Injector|null { return this._parent; }\n/**\n * @param {?} providers\n * @return {?}\n */\nresolveAndCreateChild(providers: Provider[]): ReflectiveInjector {\n const /** @type {?} */ ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);\n return this.createChildFromResolved(ResolvedReflectiveProviders);\n }\n/**\n * @param {?} providers\n * @return {?}\n */\ncreateChildFromResolved(providers: ResolvedReflectiveProvider[]): ReflectiveInjector {\n const /** @type {?} */ inj = new ReflectiveInjector_(providers);\n inj._parent = this;\n return inj;\n }\n/**\n * @param {?} provider\n * @return {?}\n */\nresolveAndInstantiate(provider: Provider): any {\n return this.instantiateResolved(ReflectiveInjector.resolve([provider])[0]);\n }\n/**\n * @param {?} provider\n * @return {?}\n */\ninstantiateResolved(provider: ResolvedReflectiveProvider): any {\n return this._instantiateProvider(provider);\n }\n/**\n * @param {?} index\n * @return {?}\n */\ngetProviderAtIndex(index: number): ResolvedReflectiveProvider {\n if (index < 0 || index >= this._providers.length) {\n throw outOfBoundsError(index);\n }\n return this._providers[index];\n }\n/**\n * \\@internal\n * @param {?} provider\n * @return {?}\n */\n_new(provider: ResolvedReflectiveProvider): any {\n if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {\n throw cyclicDependencyError(this, provider.key);\n }\n return this._instantiateProvider(provider);\n }\n/**\n * @return {?}\n */\nprivate _getMaxNumberOfObjects(): number { return this.objs.length; }\n/**\n * @param {?} provider\n * @return {?}\n */\nprivate _instantiateProvider(provider: ResolvedReflectiveProvider): any {\n if (provider.multiProvider) {\n const /** @type {?} */ res = new Array(provider.resolvedFactories.length);\n for (let /** @type {?} */ i = 0; i < provider.resolvedFactories.length; ++i) {\n res[i] = this._instantiate(provider, provider.resolvedFactories[i]);\n }\n return res;\n } else {\n return this._instantiate(provider, provider.resolvedFactories[0]);\n }\n }\n/**\n * @param {?} provider\n * @param {?} ResolvedReflectiveFactory\n * @return {?}\n */\nprivate _instantiate(\n provider: ResolvedReflectiveProvider,\n ResolvedReflectiveFactory: ResolvedReflectiveFactory): any {\n const /** @type {?} */ factory = ResolvedReflectiveFactory.factory;\n\n let /** @type {?} */ deps: any[];\n try {\n deps =\n ResolvedReflectiveFactory.dependencies.map(dep => this._getByReflectiveDependency(dep));\n } catch ( /** @type {?} */e) {\n if (e.addKey) {\n e.addKey(this, provider.key);\n }\n throw e;\n }\n\n let /** @type {?} */ obj: any;\n try {\n obj = factory(...deps);\n } catch ( /** @type {?} */e) {\n throw instantiationError(this, e, e.stack, provider.key);\n }\n\n return obj;\n }\n/**\n * @param {?} dep\n * @return {?}\n */\nprivate _getByReflectiveDependency(dep: ReflectiveDependency): any {\n return this._getByKey(dep.key, dep.visibility, dep.optional ? null : THROW_IF_NOT_FOUND);\n }\n/**\n * @param {?} key\n * @param {?} visibility\n * @param {?} notFoundValue\n * @return {?}\n */\nprivate _getByKey(key: ReflectiveKey, visibility: Self|SkipSelf|null, notFoundValue: any): any {\n if (key === INJECTOR_KEY) {\n return this;\n }\n\n if (visibility instanceof Self) {\n return this._getByKeySelf(key, notFoundValue);\n\n } else {\n return this._getByKeyDefault(key, notFoundValue, visibility);\n }\n }\n/**\n * @param {?} keyId\n * @return {?}\n */\nprivate _getObjByKeyId(keyId: number): any {\n for (let /** @type {?} */ i = 0; i < this.keyIds.length; i++) {\n if (this.keyIds[i] === keyId) {\n if (this.objs[i] === UNDEFINED) {\n this.objs[i] = this._new(this._providers[i]);\n }\n\n return this.objs[i];\n }\n }\n\n return UNDEFINED;\n }\n/**\n * \\@internal\n * @param {?} key\n * @param {?} notFoundValue\n * @return {?}\n */\n_throwOrNull(key: ReflectiveKey, notFoundValue: any): any {\n if (notFoundValue !== THROW_IF_NOT_FOUND) {\n return notFoundValue;\n } else {\n throw noProviderError(this, key);\n }\n }\n/**\n * \\@internal\n * @param {?} key\n * @param {?} notFoundValue\n * @return {?}\n */\n_getByKeySelf(key: ReflectiveKey, notFoundValue: any): any {\n const /** @type {?} */ obj = this._getObjByKeyId(key.id);\n return (obj !== UNDEFINED) ? obj : this._throwOrNull(key, notFoundValue);\n }\n/**\n * \\@internal\n * @param {?} key\n * @param {?} notFoundValue\n * @param {?} visibility\n * @return {?}\n */\n_getByKeyDefault(key: ReflectiveKey, notFoundValue: any, visibility: Self|SkipSelf|null): any {\n let /** @type {?} */ inj: Injector|null;\n\n if (visibility instanceof SkipSelf) {\n inj = this._parent;\n } else {\n inj = this;\n }\n\n while (inj instanceof ReflectiveInjector_) {\n const /** @type {?} */ inj_ = /** @type {?} */(( <ReflectiveInjector_>inj));\n const /** @type {?} */ obj = inj_._getObjByKeyId(key.id);\n if (obj !== UNDEFINED) return obj;\n inj = inj_._parent;\n }\n if (inj !== null) {\n return inj.get(key.token, notFoundValue);\n } else {\n return this._throwOrNull(key, notFoundValue);\n }\n }\n/**\n * @return {?}\n */\nget displayName(): string {\n const /** @type {?} */ providers =\n _mapProviders(this, (b: ResolvedReflectiveProvider) => ' \"' + b.key.displayName + '\" ')\n .join(', ');\n return `ReflectiveInjector(providers: [${providers}])`;\n }\n/**\n * @return {?}\n */\ntoString(): string { return this.displayName; }\n}\n\nfunction ReflectiveInjector__tsickle_Closure_declarations() {\n/**\n * \\@internal\n * @type {?}\n */\nReflectiveInjector_.prototype._constructionCounter;\n/**\n * \\@internal\n * @type {?}\n */\nReflectiveInjector_.prototype._providers;\n/**\n * \\@internal\n * @type {?}\n */\nReflectiveInjector_.prototype._parent;\n/** @type {?} */\nReflectiveInjector_.prototype.keyIds;\n/** @type {?} */\nReflectiveInjector_.prototype.objs;\n}\n\n\nconst /** @type {?} */ INJECTOR_KEY = ReflectiveKey.get(Injector);\n/**\n * @param {?} injector\n * @param {?} fn\n * @return {?}\n */\nfunction _mapProviders(injector: ReflectiveInjector_, fn: Function): any[] {\n const /** @type {?} */ res: any[] = new Array(injector._providers.length);\n for (let /** @type {?} */ i = 0; i < injector._providers.length; ++i) {\n res[i] = fn(injector.getProviderAtIndex(i));\n }\n return res;\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 {isPromise} from '../src/util/lang';\n\nimport {Inject, Injectable, InjectionToken, Optional} from './di';\n/**\n * A function that will be executed when an application is initialized.\n * \\@experimental\n */\nexport const APP_INITIALIZER = new InjectionToken<Array<() => void>>('Application Initializer');\n/**\n * A class that reflects the state of running {\\@link APP_INITIALIZER}s.\n * \n * \\@experimental\n */\nexport class ApplicationInitStatus {\nprivate _donePromise: Promise<any>;\nprivate _done = false;\n/**\n * @param {?} appInits\n */\nconstructor( appInits: (() => any)[]) {\n const asyncInitPromises: Promise<any>[] = [];\n if (appInits) {\n for (let i = 0; i < appInits.length; i++) {\n const initResult = appInits[i]();\n if (isPromise(initResult)) {\n asyncInitPromises.push(initResult);\n }\n }\n }\n this._donePromise = Promise.all(asyncInitPromises).then(() => { this._done = true; });\n if (asyncInitPromises.length === 0) {\n this._done = true;\n }\n }\n/**\n * @return {?}\n */\nget done(): boolean { return this._done; }\n/**\n * @return {?}\n */\nget donePromise(): Promise<any> { return this._donePromise; }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: Array, decorators: [{ type: Inject, args: [APP_INITIALIZER, ] }, { type: Optional }, ]},\n];\n}\n\nfunction ApplicationInitStatus_tsickle_Closure_declarations() {\n/** @type {?} */\nApplicationInitStatus.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nApplicationInitStatus.ctorParameters;\n/** @type {?} */\nApplicationInitStatus.prototype._donePromise;\n/** @type {?} */\nApplicationInitStatus.prototype._done;\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 {ChangeDetectionStrategy} from '../change_detection/constants';\nimport {Provider} from '../di';\nimport {Type} from '../type';\nimport {TypeDecorator, makeDecorator, makePropDecorator} from '../util/decorators';\n\nimport {ViewEncapsulation} from './view';\n\n\n/**\n * Type of the Directive decorator / constructor function.\n *\n * @stable\n */\nexport interface DirectiveDecorator {\n /**\n * @whatItDoes Marks a class as an Angular directive and collects directive configuration\n * metadata.\n *\n * @howToUse\n *\n * ```\n * import {Directive} from '@angular/core';\n *\n * @Directive({\n * selector: 'my-directive',\n * })\n * export class MyDirective {\n * }\n * ```\n *\n * @description\n *\n * Directive decorator allows you to mark a class as an Angular directive and provide additional\n * metadata that determines how the directive should be processed, instantiated and used at\n * runtime.\n *\n * Directives allow you to attach behavior to elements in the DOM..\n *\n * A directive must belong to an NgModule in order for it to be usable\n * by another directive, component, or application. To specify that a directive is a member of an\n * NgModule,\n * you should list it in the `declarations` field of that NgModule.\n *\n * In addition to the metadata configuration specified via the Directive decorator,\n * directives can control their runtime behavior by implementing various Life-Cycle hooks.\n *\n * **Metadata Properties:**\n *\n * * **exportAs** - name under which the component instance is exported in a template\n * * **host** - map of class property to host element bindings for events, properties and\n * attributes\n * * **inputs** - list of class property names to data-bind as component inputs\n * * **outputs** - list of class property names that expose output events that others can\n * subscribe to\n * * **providers** - list of providers available to this component and its children\n * * **queries** - configure queries that can be injected into the component\n * * **selector** - css selector that identifies this component in a template\n *\n * @stable\n * @Annotation\n */\n (obj: Directive): TypeDecorator;\n\n /**\n * See the {@link Directive} decorator.\n */\n new (obj: Directive): Directive;\n}\n\nexport interface Directive {\n /**\n * The CSS selector that triggers the instantiation of a directive.\n *\n * Angular only allows directives to trigger on CSS selectors that do not cross element\n * boundaries.\n *\n * `selector` may be declared as one of the following:\n *\n * - `element-name`: select by element name.\n * - `.class`: select by class name.\n * - `[attribute]`: select by attribute name.\n * - `[attribute=value]`: select by attribute name and value.\n * - `:not(sub_selector)`: select only if the element does not match the `sub_selector`.\n * - `selector1, selector2`: select if either `selector1` or `selector2` matches.\n *\n *\n * ### Example\n *\n * Suppose we have a directive with an `input[type=text]` selector.\n *\n * And the following HTML:\n *\n * ```html\n * <form>\n * <input type=\"text\">\n * <input type=\"radio\">\n * <form>\n * ```\n *\n * The directive would only be instantiated on the `<input type=\"text\">` element.\n *\n */\n selector?: string;\n\n /**\n * Enumerates the set of data-bound input properties for a directive\n *\n * Angular automatically updates input properties during change detection.\n *\n * The `inputs` property defines a set of `directiveProperty` to `bindingProperty`\n * configuration:\n *\n * - `directiveProperty` specifies the component property where the value is written.\n * - `bindingProperty` specifies the DOM property where the value is read from.\n *\n * When `bindingProperty` is not provided, it is assumed to be equal to `directiveProperty`.\n *\n * ### Example ([live demo](http://plnkr.co/edit/ivhfXY?p=preview))\n *\n * The following example creates a component with two data-bound properties.\n *\n * ```typescript\n * @Component({\n * selector: 'bank-account',\n * inputs: ['bankName', 'id: account-id'],\n * template: `\n * Bank Name: {{bankName}}\n * Account Id: {{id}}\n * `\n * })\n * class BankAccount {\n * bankName: string;\n * id: string;\n *\n * // this property is not bound, and won't be automatically updated by Angular\n * normalizedBankName: string;\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `\n * <bank-account bank-name=\"RBC\" account-id=\"4747\"></bank-account>\n * `\n * })\n * class App {}\n * ```\n *\n */\n inputs?: string[];\n\n /**\n * Enumerates the set of event-bound output properties.\n *\n * When an output property emits an event, an event handler attached to that event\n * the template is invoked.\n *\n * The `outputs` property defines a set of `directiveProperty` to `bindingProperty`\n * configuration:\n *\n * - `directiveProperty` specifies the component property that emits events.\n * - `bindingProperty` specifies the DOM property the event handler is attached to.\n *\n * ### Example ([live demo](http://plnkr.co/edit/d5CNq7?p=preview))\n *\n * ```typescript\n * @Directive({\n * selector: 'interval-dir',\n * outputs: ['everySecond', 'five5Secs: everyFiveSeconds']\n * })\n * class IntervalDir {\n * everySecond = new EventEmitter();\n * five5Secs = new EventEmitter();\n *\n * constructor() {\n * setInterval(() => this.everySecond.emit(\"event\"), 1000);\n * setInterval(() => this.five5Secs.emit(\"event\"), 5000);\n * }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `\n * <interval-dir (everySecond)=\"everySecond()\" (everyFiveSeconds)=\"everyFiveSeconds()\">\n * </interval-dir>\n * `\n * })\n * class App {\n * everySecond() { console.log('second'); }\n * everyFiveSeconds() { console.log('five seconds'); }\n * }\n * ```\n *\n */\n outputs?: string[];\n\n /**\n * Specify the events, actions, properties and attributes related to the host element.\n *\n * ## Host Listeners\n *\n * Specifies which DOM events a directive listens to via a set of `(event)` to `method`\n * key-value pairs:\n *\n * - `event`: the DOM event that the directive listens to.\n * - `statement`: the statement to execute when the event occurs.\n * If the evaluation of the statement returns `false`, then `preventDefault`is applied on the DOM\n * event.\n *\n * To listen to global events, a target must be added to the event name.\n * The target can be `window`, `document` or `body`.\n *\n * When writing a directive event binding, you can also refer to the $event local variable.\n *\n * ### Example ([live demo](http://plnkr.co/edit/DlA5KU?p=preview))\n *\n * The following example declares a directive that attaches a click listener to the button and\n * counts clicks.\n *\n * ```typescript\n * @Directive({\n * selector: 'button[counting]',\n * host: {\n * '(click)': 'onClick($event.target)'\n * }\n * })\n * class CountClicks {\n * numberOfClicks = 0;\n *\n * onClick(btn) {\n * console.log(\"button\", btn, \"number of clicks:\", this.numberOfClicks++);\n * }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `<button counting>Increment</button>`\n * })\n * class App {}\n * ```\n *\n * ## Host Property Bindings\n *\n * Specifies which DOM properties a directive updates.\n *\n * Angular automatically checks host property bindings during change detection.\n * If a binding changes, it will update the host element of the directive.\n *\n * ### Example ([live demo](http://plnkr.co/edit/gNg0ED?p=preview))\n *\n * The following example creates a directive that sets the `valid` and `invalid` classes\n * on the DOM element that has ngModel directive on it.\n *\n * ```typescript\n * @Directive({\n * selector: '[ngModel]',\n * host: {\n * '[class.valid]': 'valid',\n * '[class.invalid]': 'invalid'\n * }\n * })\n * class NgModelStatus {\n * constructor(public control:NgModel) {}\n * get valid { return this.control.valid; }\n * get invalid { return this.control.invalid; }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `<input [(ngModel)]=\"prop\">`\n * })\n * class App {\n * prop;\n * }\n * ```\n *\n * ## Attributes\n *\n * Specifies static attributes that should be propagated to a host element.\n *\n * ### Example\n *\n * In this example using `my-button` directive (ex.: `<div my-button></div>`) on a host element\n * (here: `<div>` ) will ensure that this element will get the \"button\" role.\n *\n * ```typescript\n * @Directive({\n * selector: '[my-button]',\n * host: {\n * 'role': 'button'\n * }\n * })\n * class MyButton {\n * }\n * ```\n */\n host?: {[key: string]: string};\n\n /**\n * Defines the set of injectable objects that are visible to a Directive and its light DOM\n * children.\n *\n * ## Simple Example\n *\n * Here is an example of a class that can be injected:\n *\n * ```\n * class Greeter {\n * greet(name:string) {\n * return 'Hello ' + name + '!';\n * }\n * }\n *\n * @Directive({\n * selector: 'greet',\n * providers: [\n * Greeter\n * ]\n * })\n * class HelloWorld {\n * greeter:Greeter;\n *\n * constructor(greeter:Greeter) {\n * this.greeter = greeter;\n * }\n * }\n * ```\n */\n providers?: Provider[];\n\n /**\n * Defines the name that can be used in the template to assign this directive to a variable.\n *\n * ## Simple Example\n *\n * ```\n * @Directive({\n * selector: 'child-dir',\n * exportAs: 'child'\n * })\n * class ChildDir {\n * }\n *\n * @Component({\n * selector: 'main',\n * template: `<child-dir #c=\"child\"></child-dir>`\n * })\n * class MainComponent {\n * }\n *\n * ```\n */\n exportAs?: string;\n\n /**\n * Configures the queries that will be injected into the directive.\n *\n * Content queries are set before the `ngAfterContentInit` callback is called.\n * View queries are set before the `ngAfterViewInit` callback is called.\n *\n * ### Example\n *\n * ```\n * @Component({\n * selector: 'someDir',\n * queries: {\n * contentChildren: new ContentChildren(ChildDirective),\n * viewChildren: new ViewChildren(ChildDirective)\n * },\n * template: '<child-directive></child-directive>'\n * })\n * class SomeDir {\n * contentChildren: QueryList<ChildDirective>,\n * viewChildren: QueryList<ChildDirective>\n *\n * ngAfterContentInit() {\n * // contentChildren is set\n * }\n *\n * ngAfterViewInit() {\n * // viewChildren is set\n * }\n * }\n * ```\n */\n queries?: {[key: string]: any};\n}\n/**\n * Directive decorator and metadata.\n * \n * \\@stable\n * \\@Annotation\n */\nexport const Directive: DirectiveDecorator = <DirectiveDecorator>makeDecorator('Directive', {\n selector: undefined,\n inputs: undefined,\n outputs: undefined,\n host: undefined,\n providers: undefined,\n exportAs: undefined,\n queries: undefined\n});\n\n/**\n * Type of the Component decorator / constructor function.\n *\n * @stable\n */\nexport interface ComponentDecorator {\n /**\n * @whatItDoes Marks a class as an Angular component and collects component configuration\n * metadata.\n *\n * @howToUse\n *\n * {@example core/ts/metadata/metadata.ts region='component'}\n *\n * @description\n * Component decorator allows you to mark a class as an Angular component and provide additional\n * metadata that determines how the component should be processed, instantiated and used at\n * runtime.\n *\n * Components are the most basic building block of an UI in an Angular application.\n * An Angular application is a tree of Angular components.\n * Angular components are a subset of directives. Unlike directives, components always have\n * a template and only one component can be instantiated per an element in a template.\n *\n * A component must belong to an NgModule in order for it to be usable\n * by another component or application. To specify that a component is a member of an NgModule,\n * you should list it in the `declarations` field of that NgModule.\n *\n * In addition to the metadata configuration specified via the Component decorator,\n * components can control their runtime behavior by implementing various Life-Cycle hooks.\n *\n * **Metadata Properties:**\n *\n * * **animations** - list of animations of this component\n * * **changeDetection** - change detection strategy used by this component\n * * **encapsulation** - style encapsulation strategy used by this component\n * * **entryComponents** - list of components that are dynamically inserted into the view of this\n * component\n * * **exportAs** - name under which the component instance is exported in a template\n * * **host** - map of class property to host element bindings for events, properties and\n * attributes\n * * **inputs** - list of class property names to data-bind as component inputs\n * * **interpolation** - custom interpolation markers used in this component's template\n * * **moduleId** - ES/CommonJS module id of the file in which this component is defined\n * * **outputs** - list of class property names that expose output events that others can\n * subscribe to\n * * **providers** - list of providers available to this component and its children\n * * **queries** - configure queries that can be injected into the component\n * * **selector** - css selector that identifies this component in a template\n * * **styleUrls** - list of urls to stylesheets to be applied to this component's view\n * * **styles** - inline-defined styles to be applied to this component's view\n * * **template** - inline-defined template for the view\n * * **templateUrl** - url to an external file containing a template for the view\n * * **viewProviders** - list of providers available to this component and its view children\n *\n * ### Example\n *\n * {@example core/ts/metadata/metadata.ts region='component'}\n *\n * @stable\n * @Annotation\n */\n (obj: Component): TypeDecorator;\n /**\n * See the {@link Component} decorator.\n */\n new (obj: Component): Component;\n}\n\n/**\n * Type of the Component metadata.\n *\n * @stable\n */\nexport interface Component extends Directive {\n /**\n * Defines the used change detection strategy.\n *\n * When a component is instantiated, Angular creates a change detector, which is responsible for\n * propagating the component's bindings.\n *\n * The `changeDetection` property defines, whether the change detection will be checked every time\n * or only when the component tells it to do so.\n */\n changeDetection?: ChangeDetectionStrategy;\n\n /**\n * Defines the set of injectable objects that are visible to its view DOM children.\n *\n * ## Simple Example\n *\n * Here is an example of a class that can be injected:\n *\n * ```\n * class Greeter {\n * greet(name:string) {\n * return 'Hello ' + name + '!';\n * }\n * }\n *\n * @Directive({\n * selector: 'needs-greeter'\n * })\n * class NeedsGreeter {\n * greeter:Greeter;\n *\n * constructor(greeter:Greeter) {\n * this.greeter = greeter;\n * }\n * }\n *\n * @Component({\n * selector: 'greet',\n * viewProviders: [\n * Greeter\n * ],\n * template: `<needs-greeter></needs-greeter>`\n * })\n * class HelloWorld {\n * }\n *\n * ```\n */\n viewProviders?: Provider[];\n\n /**\n * The module id of the module that contains the component.\n * Needed to be able to resolve relative urls for templates and styles.\n * In CommonJS, this can always be set to `module.id`, similarly SystemJS exposes `__moduleName`\n * variable within each module.\n *\n *\n * ## Simple Example\n *\n * ```\n * @Directive({\n * selector: 'someDir',\n * moduleId: module.id\n * })\n * class SomeDir {\n * }\n *\n * ```\n */\n moduleId?: string;\n\n /**\n * Specifies a template URL for an Angular component.\n *\n *Only one of `templateUrl` or `template` can be defined per View.\n */\n templateUrl?: string;\n\n /**\n * Specifies an inline template for an Angular component.\n *\n * Only one of `templateUrl` or `template` can be defined per Component.\n */\n template?: string;\n\n /**\n * Specifies stylesheet URLs for an Angular component.\n */\n styleUrls?: string[];\n\n /**\n * Specifies inline stylesheets for an Angular component.\n */\n styles?: string[];\n\n /**\n * Animations are defined on components via an animation-like DSL. This DSL approach to describing\n * animations allows for a flexibility that both benefits developers and the framework.\n *\n * Animations work by listening on state changes that occur on an element within\n * the template. When a state change occurs, Angular can then take advantage and animate the\n * arc in between. This works similar to how CSS transitions work, however, by having a\n * programmatic DSL, animations are not limited to environments that are DOM-specific.\n * (Angular can also perform optimizations behind the scenes to make animations more performant.)\n *\n * For animations to be available for use, animation state changes are placed within\n * {@link trigger animation triggers} which are housed inside of the `animations` annotation\n * metadata. Within a trigger both {@link state state} and {@link transition transition} entries\n * can be placed.\n *\n * ```typescript\n * @Component({\n * selector: 'animation-cmp',\n * templateUrl: 'animation-cmp.html',\n * animations: [\n * // this here is our animation trigger that\n * // will contain our state change animations.\n * trigger('myTriggerName', [\n * // the styles defined for the `on` and `off`\n * // states declared below are persisted on the\n * // element once the animation completes.\n * state('on', style({ opacity: 1 }),\n * state('off', style({ opacity: 0 }),\n *\n * // this here is our animation that kicks off when\n * // this state change jump is true\n * transition('on => off', [\n * animate(\"1s\")\n * ])\n * ])\n * ]\n * })\n * ```\n *\n * As depicted in the code above, a group of related animation states are all contained within\n * an animation `trigger` (the code example above called the trigger `myTriggerName`).\n * When a trigger is created then it can be bound onto an element within the component's\n * template via a property prefixed by an `@` symbol followed by trigger name and an expression\n * that\n * is used to determine the state value for that trigger.\n *\n * ```html\n * <!-- animation-cmp.html -->\n * <div @myTriggerName=\"expression\">...</div>\n * ```\n *\n * For state changes to be executed, the `expression` value must change value from its existing\n * value\n * to something that we have set an animation to animate on (in the example above we are listening\n * to a change of state between `on` and `off`). The `expression` value attached to the trigger\n * must be something that can be evaluated with the template/component context.\n *\n * ### DSL Animation Functions\n *\n * Please visit each of the animation DSL functions listed below to gain a better understanding\n * of how and why they are used for crafting animations in Angular:\n *\n * - {@link trigger trigger()}\n * - {@link state state()}\n * - {@link transition transition()}\n * - {@link group group()}\n * - {@link sequence sequence()}\n * - {@link style style()}\n * - {@link animate animate()}\n * - {@link keyframes keyframes()}\n */\n animations?: any[];\n\n /**\n * Specifies how the template and the styles should be encapsulated:\n * - {@link ViewEncapsulation#Native `ViewEncapsulation.Native`} to use shadow roots - only works\n * if natively available on the platform,\n * - {@link ViewEncapsulation#Emulated `ViewEncapsulation.Emulated`} to use shimmed CSS that\n * emulates the native behavior,\n * - {@link ViewEncapsulation#None `ViewEncapsulation.None`} to use global CSS without any\n * encapsulation.\n *\n * When no `encapsulation` is defined for the component, the default value from the\n * {@link CompilerOptions} is used. The default is `ViewEncapsulation.Emulated`}. Provide a new\n * `CompilerOptions` to override this value.\n *\n * If the encapsulation is set to `ViewEncapsulation.Emulated` and the component has no `styles`\n * nor `styleUrls` the encapsulation will automatically be switched to `ViewEncapsulation.None`.\n */\n encapsulation?: ViewEncapsulation;\n\n /**\n * Overrides the default encapsulation start and end delimiters (respectively `{{` and `}}`)\n */\n interpolation?: [string, string];\n\n /**\n * Defines the components that should be compiled as well when\n * this component is defined. For each components listed here,\n * Angular will create a {@link ComponentFactory} and store it in the\n * {@link ComponentFactoryResolver}.\n */\n entryComponents?: Array<Type<any>|any[]>;\n}\n/**\n * Component decorator and metadata.\n * \n * \\@stable\n * \\@Annotation\n */\nexport const Component: ComponentDecorator = <ComponentDecorator>makeDecorator(\n 'Component', {\n selector: undefined,\n inputs: undefined,\n outputs: undefined,\n host: undefined,\n exportAs: undefined,\n moduleId: undefined,\n providers: undefined,\n viewProviders: undefined,\n changeDetection: ChangeDetectionStrategy.Default,\n queries: undefined,\n templateUrl: undefined,\n template: undefined,\n styleUrls: undefined,\n styles: undefined,\n animations: undefined,\n encapsulation: undefined,\n interpolation: undefined,\n entryComponents: undefined\n },\n Directive);\n\n/**\n * Type of the Pipe decorator / constructor function.\n *\n * @stable\n */\nexport interface PipeDecorator {\n /**\n * Declare reusable pipe function.\n *\n * A \"pure\" pipe is only re-evaluated when either the input or any of the arguments change.\n *\n * When not specified, pipes default to being pure.\n */\n (obj: Pipe): TypeDecorator;\n\n /**\n * See the {@link Pipe} decorator.\n */\n new (obj: Pipe): Pipe;\n}\n\n/**\n * Type of the Pipe metadata.\n *\n * @stable\n */\nexport interface Pipe {\n name: string;\n pure?: boolean;\n}\n/**\n * Pipe decorator and metadata.\n * \n * \\@stable\n * \\@Annotation\n */\nexport const Pipe: PipeDecorator = <PipeDecorator>makeDecorator('Pipe', {\n name: undefined,\n pure: true,\n});\n\n\n/**\n * Type of the Input decorator / constructor function.\n *\n * @stable\n */\nexport interface InputDecorator {\n /**\n * Declares a data-bound input property.\n *\n * Angular automatically updates data-bound properties during change detection.\n *\n * `Input` takes an optional parameter that specifies the name\n * used when instantiating a component in the template. When not provided,\n * the name of the decorated property is used.\n *\n * ### Example\n *\n * The following example creates a component with two input properties.\n *\n * ```typescript\n * @Component({\n * selector: 'bank-account',\n * template: `\n * Bank Name: {{bankName}}\n * Account Id: {{id}}\n * `\n * })\n * class BankAccount {\n * @Input() bankName: string;\n * @Input('account-id') id: string;\n *\n * // this property is not bound, and won't be automatically updated by Angular\n * normalizedBankName: string;\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `\n * <bank-account bank-name=\"RBC\" account-id=\"4747\"></bank-account>\n * `\n * })\n *\n * class App {}\n * ```\n * @stable\n */\n (bindingPropertyName?: string): any;\n new (bindingPropertyName?: string): any;\n}\n\n/**\n * Type of the Input metadata.\n *\n * @stable\n */\nexport interface Input {\n /**\n * Name used when instantiating a component in the template.\n */\n bindingPropertyName?: string;\n}\n/**\n * Input decorator and metadata.\n * \n * \\@stable\n * \\@Annotation\n */\nexport const Input: InputDecorator =\n makePropDecorator('Input', [['bindingPropertyName', undefined]]);\n\n/**\n * Type of the Output decorator / constructor function.\n *\n * @stable\n */\nexport interface OutputDecorator {\n /**\n * Declares an event-bound output property.\n *\n * When an output property emits an event, an event handler attached to that event\n * the template is invoked.\n *\n * `Output` takes an optional parameter that specifies the name\n * used when instantiating a component in the template. When not provided,\n * the name of the decorated property is used.\n *\n * ### Example\n *\n * ```typescript\n * @Directive({\n * selector: 'interval-dir',\n * })\n * class IntervalDir {\n * @Output() everySecond = new EventEmitter();\n * @Output('everyFiveSeconds') five5Secs = new EventEmitter();\n *\n * constructor() {\n * setInterval(() => this.everySecond.emit(\"event\"), 1000);\n * setInterval(() => this.five5Secs.emit(\"event\"), 5000);\n * }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `\n * <interval-dir (everySecond)=\"everySecond()\" (everyFiveSeconds)=\"everyFiveSeconds()\">\n * </interval-dir>\n * `\n * })\n * class App {\n * everySecond() { console.log('second'); }\n * everyFiveSeconds() { console.log('five seconds'); }\n * }\n * ```\n * @stable\n */\n (bindingPropertyName?: string): any;\n new (bindingPropertyName?: string): any;\n}\n\n/**\n * Type of the Output metadata.\n *\n * @stable\n */\nexport interface Output { bindingPropertyName?: string; }\n/**\n * Output decorator and metadata.\n * \n * \\@stable\n * \\@Annotation\n */\nexport const Output: OutputDecorator =\n makePropDecorator('Output', [['bindingPropertyName', undefined]]);\n\n\n/**\n * Type of the HostBinding decorator / constructor function.\n *\n * @stable\n */\nexport interface HostBindingDecorator {\n /**\n * Declares a host property binding.\n *\n * Angular automatically checks host property bindings during change detection.\n * If a binding changes, it will update the host element of the directive.\n *\n * `HostBinding` takes an optional parameter that specifies the property\n * name of the host element that will be updated. When not provided,\n * the class property name is used.\n *\n * ### Example\n *\n * The following example creates a directive that sets the `valid` and `invalid` classes\n * on the DOM element that has ngModel directive on it.\n *\n * ```typescript\n * @Directive({selector: '[ngModel]'})\n * class NgModelStatus {\n * constructor(public control:NgModel) {}\n * @HostBinding('class.valid') get valid() { return this.control.valid; }\n * @HostBinding('class.invalid') get invalid() { return this.control.invalid; }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: `<input [(ngModel)]=\"prop\">`,\n * })\n * class App {\n * prop;\n * }\n * ```\n * @stable\n */\n (hostPropertyName?: string): any;\n new (hostPropertyName?: string): any;\n}\n\n/**\n * Type of the HostBinding metadata.\n *\n * @stable\n */\nexport interface HostBinding { hostPropertyName?: string; }\n/**\n * HostBinding decorator and metadata.\n * \n * \\@stable\n * \\@Annotation\n */\nexport const HostBinding: HostBindingDecorator =\n makePropDecorator('HostBinding', [['hostPropertyName', undefined]]);\n\n\n/**\n * Type of the HostListener decorator / constructor function.\n *\n * @stable\n */\nexport interface HostListenerDecorator {\n /**\n * Declares a host listener.\n *\n * Angular will invoke the decorated method when the host element emits the specified event.\n *\n * If the decorated method returns `false`, then `preventDefault` is applied on the DOM event.\n *\n * ### Example\n *\n * The following example declares a directive that attaches a click listener to the button and\n * counts clicks.\n *\n * ```typescript\n * @Directive({selector: 'button[counting]'})\n * class CountClicks {\n * numberOfClicks = 0;\n *\n * @HostListener('click', ['$event.target'])\n * onClick(btn) {\n * console.log('button', btn, 'number of clicks:', this.numberOfClicks++);\n * }\n * }\n *\n * @Component({\n * selector: 'app',\n * template: '<button counting>Increment</button>',\n * })\n * class App {}\n * ```\n * @stable\n * @Annotation\n */\n (eventName: string, args?: string[]): any;\n new (eventName: string, args?: string[]): any;\n}\n\n/**\n * Type of the HostListener metadata.\n *\n * @stable\n */\nexport interface HostListener {\n eventName?: string;\n args?: string[];\n}\n/**\n * HostListener decorator and metadata.\n * \n * \\@stable\n * \\@Annotation\n */\nexport const HostListener: HostListenerDecorator =\n makePropDecorator('HostListener', [['eventName', undefined], ['args', []]]);\n","\nexport type ViewEncapsulation = number;\nexport let ViewEncapsulation: any = {};\nViewEncapsulation.Emulated = 0;\nViewEncapsulation.Native = 1;\nViewEncapsulation.None = 2;\nViewEncapsulation[ViewEncapsulation.Emulated] = \"Emulated\";\nViewEncapsulation[ViewEncapsulation.Native] = \"Native\";\nViewEncapsulation[ViewEncapsulation.None] = \"None\";\n\n/**\n * Metadata properties available for configuring Views.\n * \n * For details on the `\\@Component` annotation, see {\\@link Component}.\n * \n * ### Example\n * \n * ```\n * \\@Component({ \n * selector: 'greet',\n * template: 'Hello {{name}}!',\n * })\n * class Greet {\n * name: string;\n * \n * constructor() {\n * this.name = 'World';\n * }\n * }\n * ```\n * \n * @deprecated Use Component instead.\n * \n * {\\@link Component}\n */\nexport class ViewMetadata {\n /** {@link Component.templateUrl} */\n templateUrl: string|undefined;\n /** {@link Component.template} */\n template: string|undefined;\n /** {@link Component.stylesUrl} */\n styleUrls: string[]|undefined;\n /** {@link Component.styles} */\n styles: string[]|undefined;\n /** {@link Component.encapsulation} */\n encapsulation: ViewEncapsulation|undefined;\n /** {@link Component.animation} */\n animations: any[]|undefined;\n /** {@link Component.interpolation} */\n interpolation: [string, string]|undefined;\n/**\n * @param {?=} __0\n */\nconstructor(\n {templateUrl, template, encapsulation, styles, styleUrls, animations, interpolation}: {\n templateUrl?: string,\n template?: string,\n encapsulation?: ViewEncapsulation,\n styles?: string[],\n styleUrls?: string[],\n animations?: any[],\n interpolation?: [string, string]\n } = {}) {\n this.templateUrl = templateUrl;\n this.template = template;\n this.styleUrls = styleUrls;\n this.styles = styles;\n this.encapsulation = encapsulation;\n this.animations = animations;\n this.interpolation = interpolation;\n }\n}\n\nfunction ViewMetadata_tsickle_Closure_declarations() {\n/**\n * {\\@link Component.templateUrl}\n * @type {?}\n */\nViewMetadata.prototype.templateUrl;\n/**\n * {\\@link Component.template}\n * @type {?}\n */\nViewMetadata.prototype.template;\n/**\n * {\\@link Component.stylesUrl}\n * @type {?}\n */\nViewMetadata.prototype.styleUrls;\n/**\n * {\\@link Component.styles}\n * @type {?}\n */\nViewMetadata.prototype.styles;\n/**\n * {\\@link Component.encapsulation}\n * @type {?}\n */\nViewMetadata.prototype.encapsulation;\n/**\n * {\\@link Component.animation}\n * @type {?}\n */\nViewMetadata.prototype.animations;\n/**\n * {\\@link Component.interpolation}\n * @type {?}\n */\nViewMetadata.prototype.interpolation;\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 * This indirection is needed to free up Component, etc symbols in the public API\n * to be used by the decorator versions of these annotations.\n */\n\n\nimport {Attribute, ContentChild, ContentChildren, Query, ViewChild, ViewChildren} from './metadata/di';\nimport {Component, Directive, HostBinding, HostListener, Input, Output, Pipe} from './metadata/directives';\nimport {ModuleWithProviders, NgModule, SchemaMetadata} from './metadata/ng_module';\nimport {ViewEncapsulation} from './metadata/view';\n\nexport {ANALYZE_FOR_ENTRY_COMPONENTS, Attribute, ContentChild, ContentChildDecorator, ContentChildren, ContentChildrenDecorator, Query, ViewChild, ViewChildDecorator, ViewChildren, ViewChildrenDecorator} from './metadata/di';\nexport {Component, ComponentDecorator, Directive, DirectiveDecorator, HostBinding, HostListener, Input, Output, Pipe} from './metadata/directives';\nexport {AfterContentChecked, AfterContentInit, AfterViewChecked, AfterViewInit, DoCheck, OnChanges, OnDestroy, OnInit} from './metadata/lifecycle_hooks';\nexport {CUSTOM_ELEMENTS_SCHEMA, ModuleWithProviders, NO_ERRORS_SCHEMA, NgModule, SchemaMetadata} from './metadata/ng_module';\nexport {ViewEncapsulation} from './metadata/view';\n","\n/**\n * \\@whatItDoes Represents the version of Angular\n * \n * \\@stable\n */\nexport class Version {\n/**\n * @param {?} full\n */\nconstructor(public full: string) {}\n/**\n * @return {?}\n */\nget major(): string { return this.full.split('.')[0]; }\n/**\n * @return {?}\n */\nget minor(): string { return this.full.split('.')[1]; }\n/**\n * @return {?}\n */\nget patch(): string { return this.full.split('.').slice(2).join('.'); }\n}\n\nfunction Version_tsickle_Closure_declarations() {\n/** @type {?} */\nVersion.prototype.full;\n}\n\n/**\n * \\@stable\n */\nexport const VERSION = new Version('4.1.1');\n","\n/**\n * Creates a token that can be used in a DI Provider.\n * \n * ### Example ([live demo](http://plnkr.co/edit/Ys9ezXpj2Mnoy3Uc8KBp?p=preview))\n * \n * ```typescript\n * var t = new OpaqueToken(\"value\");\n * \n * var injector = Injector.resolveAndCreate([\n * {provide: t, useValue: \"bindingValue\"}\n * ]);\n * \n * expect(injector.get(t)).toEqual(\"bindingValue\");\n * ```\n * \n * Using an `OpaqueToken` is preferable to using strings as tokens because of possible collisions\n * caused by multiple providers using the same string as two different tokens.\n * \n * Using an `OpaqueToken` is preferable to using an `Object` as tokens because it provides better\n * error messages.\n * @deprecated since v4.0.0 because it does not support type information, use `InjectionToken<?>`\n * instead.\n */\nexport class OpaqueToken {\n/**\n * @param {?} _desc\n */\nconstructor(protected _desc: string) {}\n/**\n * @return {?}\n */\ntoString(): string { return `Token ${this._desc}`; }\n}\n\nfunction OpaqueToken_tsickle_Closure_declarations() {\n/** @type {?} */\nOpaqueToken.prototype._desc;\n}\n\n/**\n * Creates a token that can be used in a DI Provider.\n * \n * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a\n * runtime representation) such as when injecting an interface, callable type, array or\n * parametrized type.\n * \n * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by\n * the `Injector`. This provides additional level of type safety.\n * \n * ```\n * interface MyInterface {...}\n * var myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));\n * // myInterface is inferred to be MyInterface.\n * ```\n * \n * ### Example\n * \n * {\\@example core/di/ts/injector_spec.ts region='InjectionToken'}\n * \n * \\@stable\n */\nexport class InjectionToken<T> extends OpaqueToken {\nprivate _differentiate_from_OpaqueToken_structurally: any;\n/**\n * @param {?} desc\n */\nconstructor(desc: string) { super(desc); }\n/**\n * @return {?}\n */\ntoString(): string { return `InjectionToken ${this._desc}`; }\n}\n\nfunction InjectionToken_tsickle_Closure_declarations() {\n/** @type {?} */\nInjectionToken.prototype._differentiate_from_OpaqueToken_structurally;\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// TODO(jteplitz602): Load WorkerGlobalScope from lib.webworker.d.ts file #3492\ndeclare var WorkerGlobalScope: any /** TODO #9100 */;\n// CommonJS / Node have global context exposed as \"global\" variable.\n// We don't want to include the whole node.d.ts this this compilation unit so we'll just fake\n// the global \"global\" var for now.\ndeclare var global: any /** TODO #9100 */;\nconst /** @type {?} */ __window = typeof window !== 'undefined' && window;\nconst /** @type {?} */ __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n self instanceof WorkerGlobalScope && self;\nconst /** @type {?} */ __global = typeof global !== 'undefined' && global;\nconst /** @type {?} */ _global: {[name: string]: any} = __window || __global || __self;\nexport {_global as global};\n\n// When Symbol.iterator doesn't exist, retrieves the key used in es6-shim\ndeclare const Symbol: any;\nlet /** @type {?} */ _symbolIterator: any = null;\n/**\n * @return {?}\n */\nexport function getSymbolIterator(): string|symbol {\n if (!_symbolIterator) {\n const /** @type {?} */ Symbol = _global['Symbol'];\n if (Symbol && Symbol.iterator) {\n _symbolIterator = Symbol.iterator;\n } else {\n // es6-shim specific logic\n const /** @type {?} */ keys = Object.getOwnPropertyNames(Map.prototype);\n for (let /** @type {?} */ i = 0; i < keys.length; ++i) {\n const /** @type {?} */ key = keys[i];\n if (key !== 'entries' && key !== 'size' &&\n ( /** @type {?} */((Map as any))).prototype[key] === Map.prototype['entries']) {\n _symbolIterator = key;\n }\n }\n }\n }\n return _symbolIterator;\n}\n/**\n * @param {?} fn\n * @return {?}\n */\nexport function scheduleMicroTask(fn: Function) {\n Zone.current.scheduleMicroTask('scheduleMicrotask', fn);\n}\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nexport function looseIdentical(a: any, b: any): boolean {\n return a === b || typeof a === 'number' && typeof b === 'number' && isNaN(a) && isNaN(b);\n}\n/**\n * @param {?} token\n * @return {?}\n */\nexport function stringify(token: any): string {\n if (typeof token === 'string') {\n return token;\n }\n\n if (token == null) {\n return '' + token;\n }\n\n if (token.overriddenName) {\n return `${token.overriddenName}`;\n }\n\n if (token.name) {\n return `${token.name}`;\n }\n\n const /** @type {?} */ res = token.toString();\n\n if (res == null) {\n return '' + res;\n }\n\n const /** @type {?} */ newLineIndex = res.indexOf('\\n');\n return newLineIndex === -1 ? res : res.substring(0, newLineIndex);\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 '../type';\nimport {global, stringify} from '../util';\n\nlet /** @type {?} */ _nextClassId = 0;\nconst /** @type {?} */ Reflect = global['Reflect'];\n\n/**\n * Declares the interface to be used with {@link Class}.\n *\n * @stable\n */\nexport type ClassDefinition = {\n /**\n * Optional argument for specifying the superclass.\n */\n extends?: Type<any>;\n\n /**\n * Required constructor function for a class.\n *\n * The function may be optionally wrapped in an `Array`, in which case additional parameter\n * annotations may be specified.\n * The number of arguments and the number of parameter annotations must match.\n *\n * See {@link Class} for example of usage.\n */\n constructor: Function | any[];\n} &\n{\n /**\n * Other methods on the class. Note that values should have type 'Function' but TS requires\n * all properties to have a narrower type than the index signature.\n */\n [x: string]: Type<any>|Function|any[];\n};\n\n/**\n * An interface implemented by all Angular type decorators, which allows them to be used as ES7\n * decorators as well as\n * Angular DSL syntax.\n *\n * DSL syntax:\n *\n * ```\n * var MyClass = ng\n * .Component({...})\n * .Class({...});\n * ```\n *\n * ES7 syntax:\n *\n * ```\n * @ng.Component({...})\n * class MyClass {...}\n * ```\n * @stable\n */\nexport interface TypeDecorator {\n /**\n * Invoke as ES7 decorator.\n */\n <T extends Type<any>>(type: T): T;\n\n // Make TypeDecorator assignable to built-in ParameterDecorator type.\n // ParameterDecorator is declared in lib.d.ts as a `declare type`\n // so we cannot declare this interface as a subtype.\n // see https://github.com/angular/angular/issues/3379#issuecomment-126169417\n (target: Object, propertyKey?: string|symbol, parameterIndex?: number): void;\n\n /**\n * Storage for the accumulated annotations so far used by the DSL syntax.\n *\n * Used by {@link Class} to annotate the generated class.\n */\n annotations: any[];\n\n /**\n * Generate a class from the definition and annotate it with {@link TypeDecorator#annotations}.\n */\n Class(obj: ClassDefinition): Type<any>;\n}\n/**\n * @param {?} annotation\n * @return {?}\n */\nfunction extractAnnotation(annotation: any): any {\n if (typeof annotation === 'function' && annotation.hasOwnProperty('annotation')) {\n // it is a decorator, extract annotation\n annotation = annotation.annotation;\n }\n return annotation;\n}\n/**\n * @param {?} fnOrArray\n * @param {?} key\n * @return {?}\n */\nfunction applyParams(fnOrArray: Function | any[] | undefined, key: string): Function {\n if (fnOrArray === Object || fnOrArray === String || fnOrArray === Function ||\n fnOrArray === Number || fnOrArray === Array) {\n throw new Error(`Can not use native ${stringify(fnOrArray)} as constructor`);\n }\n\n if (typeof fnOrArray === 'function') {\n return fnOrArray;\n }\n\n if (Array.isArray(fnOrArray)) {\n const /** @type {?} */ annotations: any[] = /** @type {?} */(( fnOrArray as any[]));\n const /** @type {?} */ annoLength = annotations.length - 1;\n const /** @type {?} */ fn: Function = fnOrArray[annoLength];\n if (typeof fn !== 'function') {\n throw new Error(\n `Last position of Class method array must be Function in key ${key} was '${stringify(fn)}'`);\n }\n if (annoLength != fn.length) {\n throw new Error(\n `Number of annotations (${annoLength}) does not match number of arguments (${fn.length}) in the function: ${stringify(fn)}`);\n }\n const /** @type {?} */ paramsAnnotations: any[][] = [];\n for (let /** @type {?} */ i = 0, /** @type {?} */ ii = annotations.length - 1; i < ii; i++) {\n const /** @type {?} */ paramAnnotations: any[] = [];\n paramsAnnotations.push(paramAnnotations);\n const /** @type {?} */ annotation = annotations[i];\n if (Array.isArray(annotation)) {\n for (let /** @type {?} */ j = 0; j < annotation.length; j++) {\n paramAnnotations.push(extractAnnotation(annotation[j]));\n }\n } else if (typeof annotation === 'function') {\n paramAnnotations.push(extractAnnotation(annotation));\n } else {\n paramAnnotations.push(annotation);\n }\n }\n Reflect.defineMetadata('parameters', paramsAnnotations, fn);\n return fn;\n }\n\n throw new Error(\n `Only Function or Array is supported in Class definition for key '${key}' is '${stringify(fnOrArray)}'`);\n}\n/**\n * Provides a way for expressing ES6 classes with parameter annotations in ES5.\n * \n * ## Basic Example\n * \n * ```\n * var Greeter = ng.Class({\n * constructor: function(name) {\n * this.name = name;\n * },\n * \n * greet: function() {\n * alert('Hello ' + this.name + '!');\n * }\n * });\n * ```\n * \n * is equivalent to ES6:\n * \n * ```\n * class Greeter {\n * constructor(name) {\n * this.name = name;\n * }\n * \n * greet() {\n * alert('Hello ' + this.name + '!');\n * }\n * }\n * ```\n * \n * or equivalent to ES5:\n * \n * ```\n * var Greeter = function (name) {\n * this.name = name;\n * }\n * \n * Greeter.prototype.greet = function () {\n * alert('Hello ' + this.name + '!');\n * }\n * ```\n * \n * ### Example with parameter annotations\n * \n * ```\n * var MyService = ng.Class({\n * constructor: [String, [new Optional(), Service], function(name, myService) {\n * ...\n * }]\n * });\n * ```\n * \n * is equivalent to ES6:\n * \n * ```\n * class MyService {\n * constructor(name: string, \\@Optional() myService: Service) {\n * ...\n * }\n * }\n * ```\n * \n * ### Example with inheritance\n * \n * ```\n * var Shape = ng.Class({\n * constructor: (color) {\n * this.color = color;\n * }\n * });\n * \n * var Square = ng.Class({\n * extends: Shape,\n * constructor: function(color, size) {\n * Shape.call(this, color);\n * this.size = size;\n * }\n * });\n * ```\n * @suppress {globalThis}\n * \\@stable\n * @param {?} clsDef\n * @return {?}\n */\nexport function Class(clsDef: ClassDefinition): Type<any> {\n const /** @type {?} */ constructor = applyParams(\n clsDef.hasOwnProperty('constructor') ? clsDef.constructor : undefined, 'constructor');\n\n let /** @type {?} */ proto = constructor.prototype;\n\n if (clsDef.hasOwnProperty('extends')) {\n if (typeof clsDef.extends === 'function') {\n ( /** @type {?} */((<Function>constructor))).prototype = proto =\n Object.create(( /** @type {?} */((<Function>clsDef.extends))).prototype);\n } else {\n throw new Error(\n `Class definition 'extends' property must be a constructor function was: ${stringify(clsDef.extends)}`);\n }\n }\n\n for (const /** @type {?} */ key in clsDef) {\n if (key !== 'extends' && key !== 'prototype' && clsDef.hasOwnProperty(key)) {\n proto[key] = applyParams(clsDef[key], key);\n }\n }\n\n if (this && this.annotations instanceof Array) {\n Reflect.defineMetadata('annotations', this.annotations, constructor);\n }\n\n const /** @type {?} */ constructorName = constructor['name'];\n if (!constructorName || constructorName === 'constructor') {\n ( /** @type {?} */((constructor as any)))['overriddenName'] = `class${_nextClassId++}`;\n }\n\n return /** @type {?} */(( <Type<any>>constructor));\n}\n/**\n * @suppress {globalThis}\n * @param {?} name\n * @param {?} props\n * @param {?=} parentClass\n * @param {?=} chainFn\n * @return {?}\n */\nexport function makeDecorator(\n name: string, props: {[name: string]: any}, parentClass?: any,\n chainFn?: (fn: Function) => void): (...args: any[]) => (cls: any) => any {\n const /** @type {?} */ metaCtor = makeMetadataCtor([props]);\n/**\n * @param {?} objOrType\n * @return {?}\n */\nfunction DecoratorFactory(objOrType: any): (cls: any) => any {\n if (!(Reflect && Reflect.getOwnMetadata)) {\n throw 'reflect-metadata shim is required when using class decorators';\n }\n\n if (this instanceof DecoratorFactory) {\n metaCtor.call(this, objOrType);\n return this;\n }\n\n const /** @type {?} */ annotationInstance = new ( /** @type {?} */((<any>DecoratorFactory)))(objOrType);\n const /** @type {?} */ chainAnnotation =\n typeof this === 'function' && Array.isArray(this.annotations) ? this.annotations : [];\n chainAnnotation.push(annotationInstance);\n const /** @type {?} */ TypeDecorator: TypeDecorator = /** @type {?} */(( <TypeDecorator>function TypeDecorator(cls: Type<any>) {\n const /** @type {?} */ annotations = Reflect.getOwnMetadata('annotations', cls) || [];\n annotations.push(annotationInstance);\n Reflect.defineMetadata('annotations', annotations, cls);\n return cls;\n }));\n TypeDecorator.annotations = chainAnnotation;\n TypeDecorator.Class = Class;\n if (chainFn) chainFn(TypeDecorator);\n return TypeDecorator;\n }\n\n if (parentClass) {\n DecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n\n DecoratorFactory.prototype.toString = () => `@${name}`;\n ( /** @type {?} */((<any>DecoratorFactory))).annotationCls = DecoratorFactory;\n return DecoratorFactory;\n}\n/**\n * @param {?} props\n * @return {?}\n */\nfunction makeMetadataCtor(props: ([string, any] | {[key: string]: any})[]): any {\n return function ctor(...args: any[]) {\n props.forEach((prop, i) => {\n const /** @type {?} */ argVal = args[i];\n if (Array.isArray(prop)) {\n // plain parameter\n this[prop[0]] = argVal === undefined ? prop[1] : argVal;\n } else {\n for (const /** @type {?} */ propName in prop) {\n this[propName] =\n argVal && argVal.hasOwnProperty(propName) ? argVal[propName] : prop[propName];\n }\n }\n });\n };\n}\n/**\n * @param {?} name\n * @param {?} props\n * @param {?=} parentClass\n * @return {?}\n */\nexport function makeParamDecorator(\n name: string, props: ([string, any] | {[name: string]: any})[], parentClass?: any): any {\n const /** @type {?} */ metaCtor = makeMetadataCtor(props);\n/**\n * @param {...?} args\n * @return {?}\n */\nfunction ParamDecoratorFactory(...args: any[]): any {\n if (this instanceof ParamDecoratorFactory) {\n metaCtor.apply(this, args);\n return this;\n }\n const /** @type {?} */ annotationInstance = new ( /** @type {?} */((<any>ParamDecoratorFactory)))(...args);\n\n ( /** @type {?} */((<any>ParamDecorator))).annotation = annotationInstance;\n return ParamDecorator;\n/**\n * @param {?} cls\n * @param {?} unusedKey\n * @param {?} index\n * @return {?}\n */\nfunction ParamDecorator(cls: any, unusedKey: any, index: number): any {\n const /** @type {?} */ parameters: (any[] | null)[] = Reflect.getOwnMetadata('parameters', cls) || [];\n\n // there might be gaps if some in between parameters do not have annotations.\n // we pad with nulls.\n while (parameters.length <= index) {\n parameters.push(null);\n }\n\n parameters[index] = parameters[index] || []; /** @type {?} */((\n parameters[index])).push(annotationInstance);\n\n Reflect.defineMetadata('parameters', parameters, cls);\n return cls;\n }\n }\n if (parentClass) {\n ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n ParamDecoratorFactory.prototype.toString = () => `@${name}`;\n ( /** @type {?} */((<any>ParamDecoratorFactory))).annotationCls = ParamDecoratorFactory;\n return ParamDecoratorFactory;\n}\n/**\n * @param {?} name\n * @param {?} props\n * @param {?=} parentClass\n * @return {?}\n */\nexport function makePropDecorator(\n name: string, props: ([string, any] | {[key: string]: any})[], parentClass?: any): any {\n const /** @type {?} */ metaCtor = makeMetadataCtor(props);\n/**\n * @param {...?} args\n * @return {?}\n */\nfunction PropDecoratorFactory(...args: any[]): any {\n if (this instanceof PropDecoratorFactory) {\n metaCtor.apply(this, args);\n return this;\n }\n\n const /** @type {?} */ decoratorInstance = new ( /** @type {?} */((<any>PropDecoratorFactory)))(...args);\n\n return function PropDecorator(target: any, name: string) {\n const /** @type {?} */ meta = Reflect.getOwnMetadata('propMetadata', target.constructor) || {};\n meta[name] = meta.hasOwnProperty(name) && meta[name] || [];\n meta[name].unshift(decoratorInstance);\n Reflect.defineMetadata('propMetadata', meta, target.constructor);\n };\n }\n\n if (parentClass) {\n PropDecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n\n PropDecoratorFactory.prototype.toString = () => `@${name}`;\n ( /** @type {?} */((<any>PropDecoratorFactory))).annotationCls = PropDecoratorFactory;\n return PropDecoratorFactory;\n}\n","\nexport type ChangeDetectionStrategy = number;\nexport let ChangeDetectionStrategy: any = {};\nChangeDetectionStrategy.OnPush = 0;\nChangeDetectionStrategy.Default = 1;\nChangeDetectionStrategy[ChangeDetectionStrategy.OnPush] = \"OnPush\";\nChangeDetectionStrategy[ChangeDetectionStrategy.Default] = \"Default\";\n\nexport type ChangeDetectorStatus = number;\nexport let ChangeDetectorStatus: any = {};\nChangeDetectorStatus.CheckOnce = 0;\nChangeDetectorStatus.Checked = 1;\nChangeDetectorStatus.CheckAlways = 2;\nChangeDetectorStatus.Detached = 3;\nChangeDetectorStatus.Errored = 4;\nChangeDetectorStatus.Destroyed = 5;\nChangeDetectorStatus[ChangeDetectorStatus.CheckOnce] = \"CheckOnce\";\nChangeDetectorStatus[ChangeDetectorStatus.Checked] = \"Checked\";\nChangeDetectorStatus[ChangeDetectorStatus.CheckAlways] = \"CheckAlways\";\nChangeDetectorStatus[ChangeDetectorStatus.Detached] = \"Detached\";\nChangeDetectorStatus[ChangeDetectorStatus.Errored] = \"Errored\";\nChangeDetectorStatus[ChangeDetectorStatus.Destroyed] = \"Destroyed\";\n\n/**\n * @param {?} changeDetectionStrategy\n * @return {?}\n */\nexport function isDefaultChangeDetectionStrategy(changeDetectionStrategy: ChangeDetectionStrategy):\n boolean {\n return changeDetectionStrategy == null ||\n changeDetectionStrategy === ChangeDetectionStrategy.Default;\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 {Renderer2} from '../render/api';\n\nimport {checkAndUpdateElementDynamic, checkAndUpdateElementInline, createElement, listenToElementOutputs} from './element';\nimport {expressionChangedAfterItHasBeenCheckedError} from './errors';\nimport {appendNgContent} from './ng_content';\nimport {callLifecycleHooksChildrenFirst, checkAndUpdateDirectiveDynamic, checkAndUpdateDirectiveInline, createDirectiveInstance, createPipeInstance, createProviderInstance} from './provider';\nimport {checkAndUpdatePureExpressionDynamic, checkAndUpdatePureExpressionInline, createPureExpression} from './pure_expression';\nimport {checkAndUpdateQuery, createQuery} from './query';\nimport {createTemplateData, createViewContainerData} from './refs';\nimport {checkAndUpdateTextDynamic, checkAndUpdateTextInline, createText} from './text';\nimport {ArgumentType, CheckType, ElementData, NodeData, NodeDef, NodeFlags, ProviderData, RootData, Services, ViewData, ViewDefinition, ViewFlags, ViewHandleEventFn, ViewState, ViewUpdateFn, asElementData, asQueryList, asTextData} from './types';\nimport {NOOP, checkBindingNoChanges, isComponentView, resolveViewDefinition} from './util';\n/**\n * @param {?} flags\n * @param {?} nodes\n * @param {?=} updateDirectives\n * @param {?=} updateRenderer\n * @return {?}\n */\nexport function viewDef(\n flags: ViewFlags, nodes: NodeDef[], updateDirectives?: ViewUpdateFn,\n updateRenderer?: ViewUpdateFn): ViewDefinition {\n // clone nodes and set auto calculated values\n let /** @type {?} */ viewBindingCount = 0;\n let /** @type {?} */ viewDisposableCount = 0;\n let /** @type {?} */ viewNodeFlags = 0;\n let /** @type {?} */ viewRootNodeFlags = 0;\n let /** @type {?} */ viewMatchedQueries = 0;\n let /** @type {?} */ currentParent: NodeDef|null = null;\n let /** @type {?} */ currentElementHasPublicProviders = false;\n let /** @type {?} */ currentElementHasPrivateProviders = false;\n let /** @type {?} */ lastRenderRootNode: NodeDef|null = null;\n for (let /** @type {?} */ i = 0; i < nodes.length; i++) {\n while (currentParent && i > currentParent.index + currentParent.childCount) {\n const /** @type {?} */ newParent: NodeDef|null = currentParent.parent;\n if (newParent) {\n newParent.childFlags |= /** @type {?} */(( currentParent.childFlags));\n newParent.childMatchedQueries |= currentParent.childMatchedQueries;\n }\n currentParent = newParent;\n }\n const /** @type {?} */ node = nodes[i];\n node.index = i;\n node.parent = currentParent;\n node.bindingIndex = viewBindingCount;\n node.outputIndex = viewDisposableCount;\n\n // renderParent needs to account for ng-container!\n let /** @type {?} */ currentRenderParent: NodeDef|null;\n if (currentParent && currentParent.flags & NodeFlags.TypeElement &&\n ! /** @type {?} */((currentParent.element)).name) {\n currentRenderParent = currentParent.renderParent;\n } else {\n currentRenderParent = currentParent;\n }\n node.renderParent = currentRenderParent;\n\n if (node.element) {\n const /** @type {?} */ elDef = node.element;\n elDef.publicProviders =\n currentParent ? /** @type {?} */(( currentParent.element)).publicProviders : Object.create(null);\n elDef.allProviders = elDef.publicProviders;\n // Note: We assume that all providers of an element are before any child element!\n currentElementHasPublicProviders = false;\n currentElementHasPrivateProviders = false;\n }\n validateNode(currentParent, node, nodes.length);\n\n viewNodeFlags |= node.flags;\n viewMatchedQueries |= node.matchedQueryIds;\n if (node.element && node.element.template) {\n viewMatchedQueries |= node.element.template.nodeMatchedQueries;\n }\n if (currentParent) {\n currentParent.childFlags |= node.flags;\n currentParent.directChildFlags |= node.flags;\n currentParent.childMatchedQueries |= node.matchedQueryIds;\n if (node.element && node.element.template) {\n currentParent.childMatchedQueries |= node.element.template.nodeMatchedQueries;\n }\n } else {\n viewRootNodeFlags |= node.flags;\n }\n\n viewBindingCount += node.bindings.length;\n viewDisposableCount += node.outputs.length;\n\n if (!currentRenderParent && (node.flags & NodeFlags.CatRenderNode)) {\n lastRenderRootNode = node;\n }\n if (node.flags & NodeFlags.CatProvider) {\n if (!currentElementHasPublicProviders) {\n currentElementHasPublicProviders = true; /** @type {?} */(( /** @type {?} */((\n // Use prototypical inheritance to not get O(n^2) complexity...\n currentParent)).element)).publicProviders =\n Object.create( /** @type {?} */(( /** @type {?} */((currentParent)).element)).publicProviders); /** @type {?} */(( /** @type {?} */((\n currentParent)).element)).allProviders = /** @type {?} */(( /** @type {?} */(( currentParent)).element)).publicProviders;\n }\n const /** @type {?} */ isPrivateService = (node.flags & NodeFlags.PrivateProvider) !== 0;\n const /** @type {?} */ isComponent = (node.flags & NodeFlags.Component) !== 0;\n if (!isPrivateService || isComponent) { /** @type {?} */(( /** @type {?} */(( /** @type {?} */((\n currentParent)).element)).publicProviders))[ /** @type {?} */((node.provider)).tokenKey] = node;\n } else {\n if (!currentElementHasPrivateProviders) {\n currentElementHasPrivateProviders = true; /** @type {?} */(( /** @type {?} */((\n // Use protoyypical inheritance to not get O(n^2) complexity...\n currentParent)).element)).allProviders =\n Object.create( /** @type {?} */(( /** @type {?} */((currentParent)).element)).publicProviders);\n } /** @type {?} */(( /** @type {?} */(( /** @type {?} */((\n currentParent)).element)).allProviders))[ /** @type {?} */((node.provider)).tokenKey] = node;\n }\n if (isComponent) { /** @type {?} */(( /** @type {?} */((\n currentParent)).element)).componentProvider = node;\n }\n }\n if (node.childCount) {\n currentParent = node;\n }\n }\n while (currentParent) {\n const /** @type {?} */ newParent = currentParent.parent;\n if (newParent) {\n newParent.childFlags |= currentParent.childFlags;\n newParent.childMatchedQueries |= currentParent.childMatchedQueries;\n }\n currentParent = newParent;\n }\n const /** @type {?} */ handleEvent: ViewHandleEventFn = (view, nodeIndex, eventName, event) => /** @type {?} */(( /** @type {?} */((\n nodes[nodeIndex].element)).handleEvent))(view, eventName, event);\n return {\n // Will be filled later...\n factory: null,\n nodeFlags: viewNodeFlags,\n rootNodeFlags: viewRootNodeFlags,\n nodeMatchedQueries: viewMatchedQueries, flags,\n nodes: nodes,\n updateDirectives: updateDirectives || NOOP,\n updateRenderer: updateRenderer || NOOP,\n handleEvent: handleEvent || NOOP,\n bindingCount: viewBindingCount,\n outputCount: viewDisposableCount, lastRenderRootNode\n };\n}\n/**\n * @param {?} parent\n * @param {?} node\n * @param {?} nodeCount\n * @return {?}\n */\nfunction validateNode(parent: NodeDef | null, node: NodeDef, nodeCount: number) {\n const /** @type {?} */ template = node.element && node.element.template;\n if (template) {\n if (!template.lastRenderRootNode) {\n throw new Error(`Illegal State: Embedded templates without nodes are not allowed!`);\n }\n if (template.lastRenderRootNode &&\n template.lastRenderRootNode.flags & NodeFlags.EmbeddedViews) {\n throw new Error(\n `Illegal State: Last root node of a template can't have embedded views, at index ${node.index}!`);\n }\n }\n if (node.flags & NodeFlags.CatProvider) {\n const /** @type {?} */ parentFlags = parent ? parent.flags : 0;\n if ((parentFlags & NodeFlags.TypeElement) === 0) {\n throw new Error(\n `Illegal State: Provider/Directive nodes need to be children of elements or anchors, at index ${node.index}!`);\n }\n }\n if (node.query) {\n if (node.flags & NodeFlags.TypeContentQuery &&\n (!parent || (parent.flags & NodeFlags.TypeDirective) === 0)) {\n throw new Error(\n `Illegal State: Content Query nodes need to be children of directives, at index ${node.index}!`);\n }\n if (node.flags & NodeFlags.TypeViewQuery && parent) {\n throw new Error(\n `Illegal State: View Query nodes have to be top level nodes, at index ${node.index}!`);\n }\n }\n if (node.childCount) {\n const /** @type {?} */ parentEnd = parent ? parent.index + parent.childCount : nodeCount - 1;\n if (node.index <= parentEnd && node.index + node.childCount > parentEnd) {\n throw new Error(\n `Illegal State: childCount of node leads outside of parent, at index ${node.index}!`);\n }\n }\n}\n/**\n * @param {?} parent\n * @param {?} anchorDef\n * @param {?=} context\n * @return {?}\n */\nexport function createEmbeddedView(parent: ViewData, anchorDef: NodeDef, context?: any): ViewData {\n // embedded views are seen as siblings to the anchor, so we need\n // to get the parent of the anchor and use it as parentIndex.\n const /** @type {?} */ view =\n createView(parent.root, parent.renderer, parent, anchorDef, /** @type {?} */(( /** @type {?} */(( anchorDef.element)).template)));\n initView(view, parent.component, context);\n createViewNodes(view);\n return view;\n}\n/**\n * @param {?} root\n * @param {?} def\n * @param {?=} context\n * @return {?}\n */\nexport function createRootView(root: RootData, def: ViewDefinition, context?: any): ViewData {\n const /** @type {?} */ view = createView(root, root.renderer, null, null, def);\n initView(view, context, context);\n createViewNodes(view);\n return view;\n}\n/**\n * @param {?} root\n * @param {?} renderer\n * @param {?} parent\n * @param {?} parentNodeDef\n * @param {?} def\n * @return {?}\n */\nfunction createView(\n root: RootData, renderer: Renderer2, parent: ViewData | null, parentNodeDef: NodeDef | null,\n def: ViewDefinition): ViewData {\n const /** @type {?} */ nodes: NodeData[] = new Array(def.nodes.length);\n const /** @type {?} */ disposables = def.outputCount ? new Array(def.outputCount) : null;\n const /** @type {?} */ view: ViewData = {\n def,\n parent,\n viewContainerParent: null, parentNodeDef,\n context: null,\n component: null, nodes,\n state: ViewState.CatInit, root, renderer,\n oldValues: new Array(def.bindingCount), disposables\n };\n return view;\n}\n/**\n * @param {?} view\n * @param {?} component\n * @param {?} context\n * @return {?}\n */\nfunction initView(view: ViewData, component: any, context: any) {\n view.component = component;\n view.context = context;\n}\n/**\n * @param {?} view\n * @return {?}\n */\nfunction createViewNodes(view: ViewData) {\n let /** @type {?} */ renderHost: any;\n if (isComponentView(view)) {\n const /** @type {?} */ hostDef = view.parentNodeDef;\n renderHost = asElementData( /** @type {?} */((view.parent)), /** @type {?} */(( /** @type {?} */(( hostDef)).parent)).index).renderElement;\n }\n const /** @type {?} */ def = view.def;\n const /** @type {?} */ nodes = view.nodes;\n for (let /** @type {?} */ i = 0; i < def.nodes.length; i++) {\n const /** @type {?} */ nodeDef = def.nodes[i];\n Services.setCurrentNode(view, i);\n let /** @type {?} */ nodeData: any;\n switch (nodeDef.flags & NodeFlags.Types) {\n case NodeFlags.TypeElement:\n const /** @type {?} */ el = /** @type {?} */(( createElement(view, renderHost, nodeDef) as any));\n let /** @type {?} */ componentView: ViewData = /** @type {?} */(( undefined));\n if (nodeDef.flags & NodeFlags.ComponentView) {\n const /** @type {?} */ compViewDef = resolveViewDefinition( /** @type {?} */(( /** @type {?} */((nodeDef.element)).componentView)));\n const /** @type {?} */ rendererType = /** @type {?} */(( nodeDef.element)).componentRendererType;\n let /** @type {?} */ compRenderer: Renderer2;\n if (!rendererType) {\n compRenderer = view.root.renderer;\n } else {\n compRenderer = view.root.rendererFactory.createRenderer(el, rendererType);\n }\n componentView = createView(\n view.root, compRenderer, view, /** @type {?} */(( nodeDef.element)).componentProvider, compViewDef);\n }\n listenToElementOutputs(view, componentView, nodeDef, el);\n nodeData = /** @type {?} */(( <ElementData>{\n renderElement: el,\n componentView,\n viewContainer: null,\n template: /** @type {?} */(( nodeDef.element)).template ? createTemplateData(view, nodeDef) : undefined\n }));\n if (nodeDef.flags & NodeFlags.EmbeddedViews) {\n nodeData.viewContainer = createViewContainerData(view, nodeDef, nodeData);\n }\n break;\n case NodeFlags.TypeText:\n nodeData = /** @type {?} */(( createText(view, renderHost, nodeDef) as any));\n break;\n case NodeFlags.TypeClassProvider:\n case NodeFlags.TypeFactoryProvider:\n case NodeFlags.TypeUseExistingProvider:\n case NodeFlags.TypeValueProvider: {\n const /** @type {?} */ instance = createProviderInstance(view, nodeDef);\n nodeData = /** @type {?} */(( <ProviderData>{instance}));\n break;\n }\n case NodeFlags.TypePipe: {\n const /** @type {?} */ instance = createPipeInstance(view, nodeDef);\n nodeData = /** @type {?} */(( <ProviderData>{instance}));\n break;\n }\n case NodeFlags.TypeDirective: {\n const /** @type {?} */ instance = createDirectiveInstance(view, nodeDef);\n nodeData = /** @type {?} */(( <ProviderData>{instance}));\n if (nodeDef.flags & NodeFlags.Component) {\n const /** @type {?} */ compView = asElementData(view, /** @type {?} */(( nodeDef.parent)).index).componentView;\n initView(compView, instance, instance);\n }\n break;\n }\n case NodeFlags.TypePureArray:\n case NodeFlags.TypePureObject:\n case NodeFlags.TypePurePipe:\n nodeData = /** @type {?} */(( createPureExpression(view, nodeDef) as any));\n break;\n case NodeFlags.TypeContentQuery:\n case NodeFlags.TypeViewQuery:\n nodeData = /** @type {?} */(( createQuery() as any));\n break;\n case NodeFlags.TypeNgContent:\n appendNgContent(view, renderHost, nodeDef);\n // no runtime data needed for NgContent...\n nodeData = undefined;\n break;\n }\n nodes[i] = nodeData;\n }\n // Create the ViewData.nodes of component views after we created everything else,\n // so that e.g. ng-content works\n execComponentViewsAction(view, ViewAction.CreateViewNodes);\n\n // fill static content and view queries\n execQueriesAction(\n view, NodeFlags.TypeContentQuery | NodeFlags.TypeViewQuery, NodeFlags.StaticQuery,\n CheckType.CheckAndUpdate);\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function checkNoChangesView(view: ViewData) {\n Services.updateDirectives(view, CheckType.CheckNoChanges);\n execEmbeddedViewsAction(view, ViewAction.CheckNoChanges);\n Services.updateRenderer(view, CheckType.CheckNoChanges);\n execComponentViewsAction(view, ViewAction.CheckNoChanges);\n // Note: We don't check queries for changes as we didn't do this in v2.x.\n // TODO(tbosch): investigate if we can enable the check again in v5.x with a nicer error message.\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function checkAndUpdateView(view: ViewData) {\n if (view.state & ViewState.BeforeFirstCheck) {\n view.state &= ~ViewState.BeforeFirstCheck;\n view.state |= ViewState.FirstCheck;\n } else {\n view.state &= ~ViewState.FirstCheck;\n }\n Services.updateDirectives(view, CheckType.CheckAndUpdate);\n execEmbeddedViewsAction(view, ViewAction.CheckAndUpdate);\n execQueriesAction(\n view, NodeFlags.TypeContentQuery, NodeFlags.DynamicQuery, CheckType.CheckAndUpdate);\n\n callLifecycleHooksChildrenFirst(\n view, NodeFlags.AfterContentChecked |\n (view.state & ViewState.FirstCheck ? NodeFlags.AfterContentInit : 0));\n\n Services.updateRenderer(view, CheckType.CheckAndUpdate);\n\n execComponentViewsAction(view, ViewAction.CheckAndUpdate);\n execQueriesAction(\n view, NodeFlags.TypeViewQuery, NodeFlags.DynamicQuery, CheckType.CheckAndUpdate);\n\n callLifecycleHooksChildrenFirst(\n view, NodeFlags.AfterViewChecked |\n (view.state & ViewState.FirstCheck ? NodeFlags.AfterViewInit : 0));\n\n if (view.def.flags & ViewFlags.OnPush) {\n view.state &= ~ViewState.ChecksEnabled;\n }\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @param {?} argStyle\n * @param {?=} v0\n * @param {?=} v1\n * @param {?=} v2\n * @param {?=} v3\n * @param {?=} v4\n * @param {?=} v5\n * @param {?=} v6\n * @param {?=} v7\n * @param {?=} v8\n * @param {?=} v9\n * @return {?}\n */\nexport function checkAndUpdateNode(\n view: ViewData, nodeDef: NodeDef, argStyle: ArgumentType, v0?: any, v1?: any, v2?: any,\n v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): boolean {\n if (argStyle === ArgumentType.Inline) {\n return checkAndUpdateNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n } else {\n return checkAndUpdateNodeDynamic(view, nodeDef, v0);\n }\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @param {?=} v0\n * @param {?=} v1\n * @param {?=} v2\n * @param {?=} v3\n * @param {?=} v4\n * @param {?=} v5\n * @param {?=} v6\n * @param {?=} v7\n * @param {?=} v8\n * @param {?=} v9\n * @return {?}\n */\nfunction checkAndUpdateNodeInline(\n view: ViewData, nodeDef: NodeDef, v0?: any, v1?: any, v2?: any, v3?: any, v4?: any, v5?: any,\n v6?: any, v7?: any, v8?: any, v9?: any): boolean {\n let /** @type {?} */ changed = false;\n switch (nodeDef.flags & NodeFlags.Types) {\n case NodeFlags.TypeElement:\n changed = checkAndUpdateElementInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n break;\n case NodeFlags.TypeText:\n changed = checkAndUpdateTextInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n break;\n case NodeFlags.TypeDirective:\n changed =\n checkAndUpdateDirectiveInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n break;\n case NodeFlags.TypePureArray:\n case NodeFlags.TypePureObject:\n case NodeFlags.TypePurePipe:\n changed =\n checkAndUpdatePureExpressionInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n break;\n }\n return changed;\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @param {?} values\n * @return {?}\n */\nfunction checkAndUpdateNodeDynamic(view: ViewData, nodeDef: NodeDef, values: any[]): boolean {\n let /** @type {?} */ changed = false;\n switch (nodeDef.flags & NodeFlags.Types) {\n case NodeFlags.TypeElement:\n changed = checkAndUpdateElementDynamic(view, nodeDef, values);\n break;\n case NodeFlags.TypeText:\n changed = checkAndUpdateTextDynamic(view, nodeDef, values);\n break;\n case NodeFlags.TypeDirective:\n changed = checkAndUpdateDirectiveDynamic(view, nodeDef, values);\n break;\n case NodeFlags.TypePureArray:\n case NodeFlags.TypePureObject:\n case NodeFlags.TypePurePipe:\n changed = checkAndUpdatePureExpressionDynamic(view, nodeDef, values);\n break;\n }\n if (changed) {\n // Update oldValues after all bindings have been updated,\n // as a setter for a property might update other properties.\n const /** @type {?} */ bindLen = nodeDef.bindings.length;\n const /** @type {?} */ bindingStart = nodeDef.bindingIndex;\n const /** @type {?} */ oldValues = view.oldValues;\n for (let /** @type {?} */ i = 0; i < bindLen; i++) {\n oldValues[bindingStart + i] = values[i];\n }\n }\n return changed;\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @param {?} argStyle\n * @param {?=} v0\n * @param {?=} v1\n * @param {?=} v2\n * @param {?=} v3\n * @param {?=} v4\n * @param {?=} v5\n * @param {?=} v6\n * @param {?=} v7\n * @param {?=} v8\n * @param {?=} v9\n * @return {?}\n */\nexport function checkNoChangesNode(\n view: ViewData, nodeDef: NodeDef, argStyle: ArgumentType, v0?: any, v1?: any, v2?: any,\n v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): any {\n if (argStyle === ArgumentType.Inline) {\n checkNoChangesNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n } else {\n checkNoChangesNodeDynamic(view, nodeDef, v0);\n }\n // Returning false is ok here as we would have thrown in case of a change.\n return false;\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @param {?} v0\n * @param {?} v1\n * @param {?} v2\n * @param {?} v3\n * @param {?} v4\n * @param {?} v5\n * @param {?} v6\n * @param {?} v7\n * @param {?} v8\n * @param {?} v9\n * @return {?}\n */\nfunction checkNoChangesNodeInline(\n view: ViewData, nodeDef: NodeDef, v0: any, v1: any, v2: any, v3: any, v4: any, v5: any, v6: any,\n v7: any, v8: any, v9: any): void {\n const /** @type {?} */ bindLen = nodeDef.bindings.length;\n if (bindLen > 0) checkBindingNoChanges(view, nodeDef, 0, v0);\n if (bindLen > 1) checkBindingNoChanges(view, nodeDef, 1, v1);\n if (bindLen > 2) checkBindingNoChanges(view, nodeDef, 2, v2);\n if (bindLen > 3) checkBindingNoChanges(view, nodeDef, 3, v3);\n if (bindLen > 4) checkBindingNoChanges(view, nodeDef, 4, v4);\n if (bindLen > 5) checkBindingNoChanges(view, nodeDef, 5, v5);\n if (bindLen > 6) checkBindingNoChanges(view, nodeDef, 6, v6);\n if (bindLen > 7) checkBindingNoChanges(view, nodeDef, 7, v7);\n if (bindLen > 8) checkBindingNoChanges(view, nodeDef, 8, v8);\n if (bindLen > 9) checkBindingNoChanges(view, nodeDef, 9, v9);\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @param {?} values\n * @return {?}\n */\nfunction checkNoChangesNodeDynamic(view: ViewData, nodeDef: NodeDef, values: any[]): void {\n for (let /** @type {?} */ i = 0; i < values.length; i++) {\n checkBindingNoChanges(view, nodeDef, i, values[i]);\n }\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @return {?}\n */\nfunction checkNoChangesQuery(view: ViewData, nodeDef: NodeDef) {\n const /** @type {?} */ queryList = asQueryList(view, nodeDef.index);\n if (queryList.dirty) {\n throw expressionChangedAfterItHasBeenCheckedError(\n Services.createDebugContext(view, nodeDef.index), `Query ${ /** @type {?} */((nodeDef.query)).id} not dirty`,\n `Query ${ /** @type {?} */((nodeDef.query)).id} dirty`, (view.state & ViewState.BeforeFirstCheck) !== 0);\n }\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function destroyView(view: ViewData) {\n if (view.state & ViewState.Destroyed) {\n return;\n }\n execEmbeddedViewsAction(view, ViewAction.Destroy);\n execComponentViewsAction(view, ViewAction.Destroy);\n callLifecycleHooksChildrenFirst(view, NodeFlags.OnDestroy);\n if (view.disposables) {\n for (let /** @type {?} */ i = 0; i < view.disposables.length; i++) {\n view.disposables[i]();\n }\n }\n if (view.renderer.destroyNode) {\n destroyViewNodes(view);\n }\n if (isComponentView(view)) {\n view.renderer.destroy();\n }\n view.state |= ViewState.Destroyed;\n}\n/**\n * @param {?} view\n * @return {?}\n */\nfunction destroyViewNodes(view: ViewData) {\n const /** @type {?} */ len = view.def.nodes.length;\n for (let /** @type {?} */ i = 0; i < len; i++) {\n const /** @type {?} */ def = view.def.nodes[i];\n if (def.flags & NodeFlags.TypeElement) { /** @type {?} */((\n view.renderer.destroyNode))(asElementData(view, i).renderElement);\n } else if (def.flags & NodeFlags.TypeText) { /** @type {?} */((\n view.renderer.destroyNode))(asTextData(view, i).renderText);\n }\n }\n}\ntype ViewAction = number;\nlet ViewAction: any = {};\nViewAction.CreateViewNodes = 0;\nViewAction.CheckNoChanges = 1;\nViewAction.CheckAndUpdate = 2;\nViewAction.Destroy = 3;\nViewAction[ViewAction.CreateViewNodes] = \"CreateViewNodes\";\nViewAction[ViewAction.CheckNoChanges] = \"CheckNoChanges\";\nViewAction[ViewAction.CheckAndUpdate] = \"CheckAndUpdate\";\nViewAction[ViewAction.Destroy] = \"Destroy\";\n\n/**\n * @param {?} view\n * @param {?} action\n * @return {?}\n */\nfunction execComponentViewsAction(view: ViewData, action: ViewAction) {\n const /** @type {?} */ def = view.def;\n if (!(def.nodeFlags & NodeFlags.ComponentView)) {\n return;\n }\n for (let /** @type {?} */ i = 0; i < def.nodes.length; i++) {\n const /** @type {?} */ nodeDef = def.nodes[i];\n if (nodeDef.flags & NodeFlags.ComponentView) {\n // a leaf\n callViewAction(asElementData(view, i).componentView, action);\n } else if ((nodeDef.childFlags & NodeFlags.ComponentView) === 0) {\n // a parent with leafs\n // no child is a component,\n // then skip the children\n i += nodeDef.childCount;\n }\n }\n}\n/**\n * @param {?} view\n * @param {?} action\n * @return {?}\n */\nfunction execEmbeddedViewsAction(view: ViewData, action: ViewAction) {\n const /** @type {?} */ def = view.def;\n if (!(def.nodeFlags & NodeFlags.EmbeddedViews)) {\n return;\n }\n for (let /** @type {?} */ i = 0; i < def.nodes.length; i++) {\n const /** @type {?} */ nodeDef = def.nodes[i];\n if (nodeDef.flags & NodeFlags.EmbeddedViews) {\n // a leaf\n const /** @type {?} */ embeddedViews = /** @type {?} */(( asElementData(view, i).viewContainer))._embeddedViews;\n for (let /** @type {?} */ k = 0; k < embeddedViews.length; k++) {\n callViewAction(embeddedViews[k], action);\n }\n } else if ((nodeDef.childFlags & NodeFlags.EmbeddedViews) === 0) {\n // a parent with leafs\n // no child is a component,\n // then skip the children\n i += nodeDef.childCount;\n }\n }\n}\n/**\n * @param {?} view\n * @param {?} action\n * @return {?}\n */\nfunction callViewAction(view: ViewData, action: ViewAction) {\n const /** @type {?} */ viewState = view.state;\n switch (action) {\n case ViewAction.CheckNoChanges:\n if ((viewState & ViewState.CatDetectChanges) === ViewState.CatDetectChanges &&\n (viewState & ViewState.Destroyed) === 0) {\n checkNoChangesView(view);\n }\n break;\n case ViewAction.CheckAndUpdate:\n if ((viewState & ViewState.CatDetectChanges) === ViewState.CatDetectChanges &&\n (viewState & ViewState.Destroyed) === 0) {\n checkAndUpdateView(view);\n }\n break;\n case ViewAction.Destroy:\n destroyView(view);\n break;\n case ViewAction.CreateViewNodes:\n createViewNodes(view);\n break;\n }\n}\n/**\n * @param {?} view\n * @param {?} queryFlags\n * @param {?} staticDynamicQueryFlag\n * @param {?} checkType\n * @return {?}\n */\nfunction execQueriesAction(\n view: ViewData, queryFlags: NodeFlags, staticDynamicQueryFlag: NodeFlags,\n checkType: CheckType) {\n if (!(view.def.nodeFlags & queryFlags) || !(view.def.nodeFlags & staticDynamicQueryFlag)) {\n return;\n }\n const /** @type {?} */ nodeCount = view.def.nodes.length;\n for (let /** @type {?} */ i = 0; i < nodeCount; i++) {\n const /** @type {?} */ nodeDef = view.def.nodes[i];\n if ((nodeDef.flags & queryFlags) && (nodeDef.flags & staticDynamicQueryFlag)) {\n Services.setCurrentNode(view, nodeDef.index);\n switch (checkType) {\n case CheckType.CheckAndUpdate:\n checkAndUpdateQuery(view, nodeDef);\n break;\n case CheckType.CheckNoChanges:\n checkNoChangesQuery(view, nodeDef);\n break;\n }\n }\n if (!(nodeDef.childFlags & queryFlags) || !(nodeDef.childFlags & staticDynamicQueryFlag)) {\n // no child has a matching query\n // then skip the children\n i += nodeDef.childCount;\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\nimport {BindingDef, BindingFlags, NodeDef, NodeFlags, TextData, ViewData, asTextData} from './types';\nimport {calcBindingFlags, checkAndUpdateBinding, getParentRenderElement} from './util';\n/**\n * @param {?} ngContentIndex\n * @param {?} constants\n * @return {?}\n */\nexport function textDef(ngContentIndex: number, constants: string[]): NodeDef {\n const /** @type {?} */ bindings: BindingDef[] = new Array(constants.length - 1);\n for (let /** @type {?} */ i = 1; i < constants.length; i++) {\n bindings[i - 1] = {\n flags: BindingFlags.TypeProperty,\n name: null,\n ns: null,\n nonMinifiedName: null,\n securityContext: null,\n suffix: constants[i]\n };\n }\n const /** @type {?} */ flags = NodeFlags.TypeText;\n return {\n // will bet set by the view definition\n index: -1,\n parent: null,\n renderParent: null,\n bindingIndex: -1,\n outputIndex: -1,\n // regular values\n flags,\n childFlags: 0,\n directChildFlags: 0,\n childMatchedQueries: 0,\n matchedQueries: {},\n matchedQueryIds: 0,\n references: {}, ngContentIndex,\n childCount: 0, bindings,\n bindingFlags: calcBindingFlags(bindings),\n outputs: [],\n element: null,\n provider: null,\n text: {prefix: constants[0]},\n query: null,\n ngContent: null\n };\n}\n/**\n * @param {?} view\n * @param {?} renderHost\n * @param {?} def\n * @return {?}\n */\nexport function createText(view: ViewData, renderHost: any, def: NodeDef): TextData {\n let /** @type {?} */ renderNode: any;\n const /** @type {?} */ renderer = view.renderer;\n renderNode = renderer.createText( /** @type {?} */((def.text)).prefix);\n const /** @type {?} */ parentEl = getParentRenderElement(view, renderHost, def);\n if (parentEl) {\n renderer.appendChild(parentEl, renderNode);\n }\n return {renderText: renderNode};\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} v0\n * @param {?} v1\n * @param {?} v2\n * @param {?} v3\n * @param {?} v4\n * @param {?} v5\n * @param {?} v6\n * @param {?} v7\n * @param {?} v8\n * @param {?} v9\n * @return {?}\n */\nexport function checkAndUpdateTextInline(\n view: ViewData, def: NodeDef, v0: any, v1: any, v2: any, v3: any, v4: any, v5: any, v6: any,\n v7: any, v8: any, v9: any): boolean {\n let /** @type {?} */ changed = false;\n const /** @type {?} */ bindings = def.bindings;\n const /** @type {?} */ bindLen = bindings.length;\n if (bindLen > 0 && checkAndUpdateBinding(view, def, 0, v0)) changed = true;\n if (bindLen > 1 && checkAndUpdateBinding(view, def, 1, v1)) changed = true;\n if (bindLen > 2 && checkAndUpdateBinding(view, def, 2, v2)) changed = true;\n if (bindLen > 3 && checkAndUpdateBinding(view, def, 3, v3)) changed = true;\n if (bindLen > 4 && checkAndUpdateBinding(view, def, 4, v4)) changed = true;\n if (bindLen > 5 && checkAndUpdateBinding(view, def, 5, v5)) changed = true;\n if (bindLen > 6 && checkAndUpdateBinding(view, def, 6, v6)) changed = true;\n if (bindLen > 7 && checkAndUpdateBinding(view, def, 7, v7)) changed = true;\n if (bindLen > 8 && checkAndUpdateBinding(view, def, 8, v8)) changed = true;\n if (bindLen > 9 && checkAndUpdateBinding(view, def, 9, v9)) changed = true;\n\n if (changed) {\n let /** @type {?} */ value = /** @type {?} */(( def.text)).prefix;\n if (bindLen > 0) value += _addInterpolationPart(v0, bindings[0]);\n if (bindLen > 1) value += _addInterpolationPart(v1, bindings[1]);\n if (bindLen > 2) value += _addInterpolationPart(v2, bindings[2]);\n if (bindLen > 3) value += _addInterpolationPart(v3, bindings[3]);\n if (bindLen > 4) value += _addInterpolationPart(v4, bindings[4]);\n if (bindLen > 5) value += _addInterpolationPart(v5, bindings[5]);\n if (bindLen > 6) value += _addInterpolationPart(v6, bindings[6]);\n if (bindLen > 7) value += _addInterpolationPart(v7, bindings[7]);\n if (bindLen > 8) value += _addInterpolationPart(v8, bindings[8]);\n if (bindLen > 9) value += _addInterpolationPart(v9, bindings[9]);\n const /** @type {?} */ renderNode = asTextData(view, def.index).renderText;\n view.renderer.setValue(renderNode, value);\n }\n return changed;\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} values\n * @return {?}\n */\nexport function checkAndUpdateTextDynamic(view: ViewData, def: NodeDef, values: any[]): boolean {\n const /** @type {?} */ bindings = def.bindings;\n let /** @type {?} */ changed = false;\n for (let /** @type {?} */ i = 0; i < values.length; i++) {\n // Note: We need to loop over all values, so that\n // the old values are updates as well!\n if (checkAndUpdateBinding(view, def, i, values[i])) {\n changed = true;\n }\n }\n if (changed) {\n let /** @type {?} */ value = '';\n for (let /** @type {?} */ i = 0; i < values.length; i++) {\n value = value + _addInterpolationPart(values[i], bindings[i]);\n }\n value = /** @type {?} */(( def.text)).prefix + value;\n const /** @type {?} */ renderNode = asTextData(view, def.index).renderText;\n view.renderer.setValue(renderNode, value);\n }\n return changed;\n}\n/**\n * @param {?} value\n * @param {?} binding\n * @return {?}\n */\nfunction _addInterpolationPart(value: any, binding: BindingDef): string {\n const /** @type {?} */ valueStr = value != null ? value.toString() : '';\n return valueStr + binding.suffix;\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 {ElementRef} from '../linker/element_ref';\nimport {QueryList} from '../linker/query_list';\n\nimport {NodeDef, NodeFlags, QueryBindingDef, QueryBindingType, QueryDef, QueryValueType, ViewData, asElementData, asProviderData, asQueryList} from './types';\nimport {declaredViewContainer, filterQueryId, isEmbeddedView} from './util';\n/**\n * @param {?} flags\n * @param {?} id\n * @param {?} bindings\n * @return {?}\n */\nexport function queryDef(\n flags: NodeFlags, id: number, bindings: {[propName: string]: QueryBindingType}): NodeDef {\n let /** @type {?} */ bindingDefs: QueryBindingDef[] = [];\n for (let /** @type {?} */ propName in bindings) {\n const /** @type {?} */ bindingType = bindings[propName];\n bindingDefs.push({propName, bindingType});\n }\n\n return {\n // will bet set by the view definition\n index: -1,\n parent: null,\n renderParent: null,\n bindingIndex: -1,\n outputIndex: -1,\n // regular values\n flags,\n childFlags: 0,\n directChildFlags: 0,\n childMatchedQueries: 0,\n ngContentIndex: -1,\n matchedQueries: {},\n matchedQueryIds: 0,\n references: {},\n childCount: 0,\n bindings: [],\n bindingFlags: 0,\n outputs: [],\n element: null,\n provider: null,\n text: null,\n query: {id, filterId: filterQueryId(id), bindings: bindingDefs},\n ngContent: null\n };\n}\n/**\n * @return {?}\n */\nexport function createQuery(): QueryList<any> {\n return new QueryList();\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function dirtyParentQueries(view: ViewData) {\n const /** @type {?} */ queryIds = view.def.nodeMatchedQueries;\n while (view.parent && isEmbeddedView(view)) {\n let /** @type {?} */ tplDef = /** @type {?} */(( view.parentNodeDef));\n view = view.parent;\n // content queries\n const /** @type {?} */ end = tplDef.index + tplDef.childCount;\n for (let /** @type {?} */ i = 0; i <= end; i++) {\n const /** @type {?} */ nodeDef = view.def.nodes[i];\n if ((nodeDef.flags & NodeFlags.TypeContentQuery) &&\n (nodeDef.flags & NodeFlags.DynamicQuery) &&\n ( /** @type {?} */((nodeDef.query)).filterId & queryIds) === /** @type {?} */(( nodeDef.query)).filterId) {\n asQueryList(view, i).setDirty();\n }\n if ((nodeDef.flags & NodeFlags.TypeElement && i + nodeDef.childCount < tplDef.index) ||\n !(nodeDef.childFlags & NodeFlags.TypeContentQuery) ||\n !(nodeDef.childFlags & NodeFlags.DynamicQuery)) {\n // skip elements that don't contain the template element or no query.\n i += nodeDef.childCount;\n }\n }\n }\n\n // view queries\n if (view.def.nodeFlags & NodeFlags.TypeViewQuery) {\n for (let /** @type {?} */ i = 0; i < view.def.nodes.length; i++) {\n const /** @type {?} */ nodeDef = view.def.nodes[i];\n if ((nodeDef.flags & NodeFlags.TypeViewQuery) && (nodeDef.flags & NodeFlags.DynamicQuery)) {\n asQueryList(view, i).setDirty();\n }\n // only visit the root nodes\n i += nodeDef.childCount;\n }\n }\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @return {?}\n */\nexport function checkAndUpdateQuery(view: ViewData, nodeDef: NodeDef) {\n const /** @type {?} */ queryList = asQueryList(view, nodeDef.index);\n if (!queryList.dirty) {\n return;\n }\n let /** @type {?} */ directiveInstance: any;\n let /** @type {?} */ newValues: any[] = /** @type {?} */(( undefined));\n if (nodeDef.flags & NodeFlags.TypeContentQuery) {\n const /** @type {?} */ elementDef = /** @type {?} */(( /** @type {?} */(( nodeDef.parent)).parent));\n newValues = calcQueryValues(\n view, elementDef.index, elementDef.index + elementDef.childCount, /** @type {?} */(( nodeDef.query)), []);\n directiveInstance = asProviderData(view, /** @type {?} */(( nodeDef.parent)).index).instance;\n } else if (nodeDef.flags & NodeFlags.TypeViewQuery) {\n newValues = calcQueryValues(view, 0, view.def.nodes.length - 1, /** @type {?} */(( nodeDef.query)), []);\n directiveInstance = view.component;\n }\n queryList.reset(newValues);\n const /** @type {?} */ bindings = /** @type {?} */(( nodeDef.query)).bindings;\n let /** @type {?} */ notify = false;\n for (let /** @type {?} */ i = 0; i < bindings.length; i++) {\n const /** @type {?} */ binding = bindings[i];\n let /** @type {?} */ boundValue: any;\n switch (binding.bindingType) {\n case QueryBindingType.First:\n boundValue = queryList.first;\n break;\n case QueryBindingType.All:\n boundValue = queryList;\n notify = true;\n break;\n }\n directiveInstance[binding.propName] = boundValue;\n }\n if (notify) {\n queryList.notifyOnChanges();\n }\n}\n/**\n * @param {?} view\n * @param {?} startIndex\n * @param {?} endIndex\n * @param {?} queryDef\n * @param {?} values\n * @return {?}\n */\nfunction calcQueryValues(\n view: ViewData, startIndex: number, endIndex: number, queryDef: QueryDef,\n values: any[]): any[] {\n for (let /** @type {?} */ i = startIndex; i <= endIndex; i++) {\n const /** @type {?} */ nodeDef = view.def.nodes[i];\n const /** @type {?} */ valueType = nodeDef.matchedQueries[queryDef.id];\n if (valueType != null) {\n values.push(getQueryValue(view, nodeDef, valueType));\n }\n if (nodeDef.flags & NodeFlags.TypeElement && /** @type {?} */(( nodeDef.element)).template &&\n ( /** @type {?} */(( /** @type {?} */((nodeDef.element)).template)).nodeMatchedQueries & queryDef.filterId) ===\n queryDef.filterId) {\n // check embedded views that were attached at the place of their template.\n const /** @type {?} */ elementData = asElementData(view, i);\n if (nodeDef.flags & NodeFlags.EmbeddedViews) {\n const /** @type {?} */ embeddedViews = /** @type {?} */(( elementData.viewContainer))._embeddedViews;\n for (let /** @type {?} */ k = 0; k < embeddedViews.length; k++) {\n const /** @type {?} */ embeddedView = embeddedViews[k];\n const /** @type {?} */ dvc = declaredViewContainer(embeddedView);\n if (dvc && dvc === elementData) {\n calcQueryValues(embeddedView, 0, embeddedView.def.nodes.length - 1, queryDef, values);\n }\n }\n }\n const /** @type {?} */ projectedViews = elementData.template._projectedViews;\n if (projectedViews) {\n for (let /** @type {?} */ k = 0; k < projectedViews.length; k++) {\n const /** @type {?} */ projectedView = projectedViews[k];\n calcQueryValues(projectedView, 0, projectedView.def.nodes.length - 1, queryDef, values);\n }\n }\n }\n if ((nodeDef.childMatchedQueries & queryDef.filterId) !== queryDef.filterId) {\n // if no child matches the query, skip the children.\n i += nodeDef.childCount;\n }\n }\n return values;\n}\n/**\n * @param {?} view\n * @param {?} nodeDef\n * @param {?} queryValueType\n * @return {?}\n */\nexport function getQueryValue(\n view: ViewData, nodeDef: NodeDef, queryValueType: QueryValueType): any {\n if (queryValueType != null) {\n // a match\n let /** @type {?} */ value: any;\n switch (queryValueType) {\n case QueryValueType.RenderElement:\n value = asElementData(view, nodeDef.index).renderElement;\n break;\n case QueryValueType.ElementRef:\n value = new ElementRef(asElementData(view, nodeDef.index).renderElement);\n break;\n case QueryValueType.TemplateRef:\n value = asElementData(view, nodeDef.index).template;\n break;\n case QueryValueType.ViewContainerRef:\n value = asElementData(view, nodeDef.index).viewContainer;\n break;\n case QueryValueType.Provider:\n value = asProviderData(view, nodeDef.index).instance;\n break;\n }\n return value;\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 {BindingDef, BindingFlags, NodeDef, NodeFlags, PureExpressionData, ViewData, asPureExpressionData} from './types';\nimport {calcBindingFlags, checkAndUpdateBinding} from './util';\n/**\n * @param {?} argCount\n * @return {?}\n */\nexport function purePipeDef(argCount: number): NodeDef {\n // argCount + 1 to include the pipe as first arg\n return _pureExpressionDef(NodeFlags.TypePurePipe, new Array(argCount + 1));\n}\n/**\n * @param {?} argCount\n * @return {?}\n */\nexport function pureArrayDef(argCount: number): NodeDef {\n return _pureExpressionDef(NodeFlags.TypePureArray, new Array(argCount));\n}\n/**\n * @param {?} propertyNames\n * @return {?}\n */\nexport function pureObjectDef(propertyNames: string[]): NodeDef {\n return _pureExpressionDef(NodeFlags.TypePureObject, propertyNames);\n}\n/**\n * @param {?} flags\n * @param {?} propertyNames\n * @return {?}\n */\nfunction _pureExpressionDef(flags: NodeFlags, propertyNames: string[]): NodeDef {\n const /** @type {?} */ bindings: BindingDef[] = new Array(propertyNames.length);\n for (let /** @type {?} */ i = 0; i < propertyNames.length; i++) {\n const /** @type {?} */ prop = propertyNames[i];\n bindings[i] = {\n flags: BindingFlags.TypeProperty,\n name: prop,\n ns: null,\n nonMinifiedName: prop,\n securityContext: null,\n suffix: null\n };\n }\n return {\n // will bet set by the view definition\n index: -1,\n parent: null,\n renderParent: null,\n bindingIndex: -1,\n outputIndex: -1,\n // regular values\n flags,\n childFlags: 0,\n directChildFlags: 0,\n childMatchedQueries: 0,\n matchedQueries: {},\n matchedQueryIds: 0,\n references: {},\n ngContentIndex: -1,\n childCount: 0, bindings,\n bindingFlags: calcBindingFlags(bindings),\n outputs: [],\n element: null,\n provider: null,\n text: null,\n query: null,\n ngContent: null\n };\n}\n/**\n * @param {?} view\n * @param {?} def\n * @return {?}\n */\nexport function createPureExpression(view: ViewData, def: NodeDef): PureExpressionData {\n return {value: undefined};\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} v0\n * @param {?} v1\n * @param {?} v2\n * @param {?} v3\n * @param {?} v4\n * @param {?} v5\n * @param {?} v6\n * @param {?} v7\n * @param {?} v8\n * @param {?} v9\n * @return {?}\n */\nexport function checkAndUpdatePureExpressionInline(\n view: ViewData, def: NodeDef, v0: any, v1: any, v2: any, v3: any, v4: any, v5: any, v6: any,\n v7: any, v8: any, v9: any): boolean {\n const /** @type {?} */ bindings = def.bindings;\n let /** @type {?} */ changed = false;\n const /** @type {?} */ bindLen = bindings.length;\n if (bindLen > 0 && checkAndUpdateBinding(view, def, 0, v0)) changed = true;\n if (bindLen > 1 && checkAndUpdateBinding(view, def, 1, v1)) changed = true;\n if (bindLen > 2 && checkAndUpdateBinding(view, def, 2, v2)) changed = true;\n if (bindLen > 3 && checkAndUpdateBinding(view, def, 3, v3)) changed = true;\n if (bindLen > 4 && checkAndUpdateBinding(view, def, 4, v4)) changed = true;\n if (bindLen > 5 && checkAndUpdateBinding(view, def, 5, v5)) changed = true;\n if (bindLen > 6 && checkAndUpdateBinding(view, def, 6, v6)) changed = true;\n if (bindLen > 7 && checkAndUpdateBinding(view, def, 7, v7)) changed = true;\n if (bindLen > 8 && checkAndUpdateBinding(view, def, 8, v8)) changed = true;\n if (bindLen > 9 && checkAndUpdateBinding(view, def, 9, v9)) changed = true;\n\n if (changed) {\n const /** @type {?} */ data = asPureExpressionData(view, def.index);\n let /** @type {?} */ value: any;\n switch (def.flags & NodeFlags.Types) {\n case NodeFlags.TypePureArray:\n value = new Array(bindings.length);\n if (bindLen > 0) value[0] = v0;\n if (bindLen > 1) value[1] = v1;\n if (bindLen > 2) value[2] = v2;\n if (bindLen > 3) value[3] = v3;\n if (bindLen > 4) value[4] = v4;\n if (bindLen > 5) value[5] = v5;\n if (bindLen > 6) value[6] = v6;\n if (bindLen > 7) value[7] = v7;\n if (bindLen > 8) value[8] = v8;\n if (bindLen > 9) value[9] = v9;\n break;\n case NodeFlags.TypePureObject:\n value = {};\n if (bindLen > 0) value[ /** @type {?} */((bindings[0].name))] = v0;\n if (bindLen > 1) value[ /** @type {?} */((bindings[1].name))] = v1;\n if (bindLen > 2) value[ /** @type {?} */((bindings[2].name))] = v2;\n if (bindLen > 3) value[ /** @type {?} */((bindings[3].name))] = v3;\n if (bindLen > 4) value[ /** @type {?} */((bindings[4].name))] = v4;\n if (bindLen > 5) value[ /** @type {?} */((bindings[5].name))] = v5;\n if (bindLen > 6) value[ /** @type {?} */((bindings[6].name))] = v6;\n if (bindLen > 7) value[ /** @type {?} */((bindings[7].name))] = v7;\n if (bindLen > 8) value[ /** @type {?} */((bindings[8].name))] = v8;\n if (bindLen > 9) value[ /** @type {?} */((bindings[9].name))] = v9;\n break;\n case NodeFlags.TypePurePipe:\n const /** @type {?} */ pipe = v0;\n switch (bindLen) {\n case 1:\n value = pipe.transform(v0);\n break;\n case 2:\n value = pipe.transform(v1);\n break;\n case 3:\n value = pipe.transform(v1, v2);\n break;\n case 4:\n value = pipe.transform(v1, v2, v3);\n break;\n case 5:\n value = pipe.transform(v1, v2, v3, v4);\n break;\n case 6:\n value = pipe.transform(v1, v2, v3, v4, v5);\n break;\n case 7:\n value = pipe.transform(v1, v2, v3, v4, v5, v6);\n break;\n case 8:\n value = pipe.transform(v1, v2, v3, v4, v5, v6, v7);\n break;\n case 9:\n value = pipe.transform(v1, v2, v3, v4, v5, v6, v7, v8);\n break;\n case 10:\n value = pipe.transform(v1, v2, v3, v4, v5, v6, v7, v8, v9);\n break;\n }\n break;\n }\n data.value = value;\n }\n return changed;\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} values\n * @return {?}\n */\nexport function checkAndUpdatePureExpressionDynamic(\n view: ViewData, def: NodeDef, values: any[]): boolean {\n const /** @type {?} */ bindings = def.bindings;\n let /** @type {?} */ changed = false;\n for (let /** @type {?} */ i = 0; i < values.length; i++) {\n // Note: We need to loop over all values, so that\n // the old values are updates as well!\n if (checkAndUpdateBinding(view, def, i, values[i])) {\n changed = true;\n }\n }\n if (changed) {\n const /** @type {?} */ data = asPureExpressionData(view, def.index);\n let /** @type {?} */ value: any;\n switch (def.flags & NodeFlags.Types) {\n case NodeFlags.TypePureArray:\n value = values;\n break;\n case NodeFlags.TypePureObject:\n value = {};\n for (let /** @type {?} */ i = 0; i < values.length; i++) {\n value[ /** @type {?} */((bindings[i].name))] = values[i];\n }\n break;\n case NodeFlags.TypePurePipe:\n const /** @type {?} */ pipe = values[0];\n const /** @type {?} */ params = values.slice(1);\n value = ( /** @type {?} */((<any>pipe.transform)))(...params);\n break;\n }\n data.value = value;\n }\n return changed;\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 {ElementData, Services, ViewData} from './types';\nimport {RenderNodeAction, declaredViewContainer, renderNode, visitRootRenderNodes} from './util';\n/**\n * @param {?} parentView\n * @param {?} elementData\n * @param {?} viewIndex\n * @param {?} view\n * @return {?}\n */\nexport function attachEmbeddedView(\n parentView: ViewData, elementData: ElementData, viewIndex: number | undefined | null,\n view: ViewData) {\n let /** @type {?} */ embeddedViews = /** @type {?} */(( elementData.viewContainer))._embeddedViews;\n if (viewIndex === null || viewIndex === undefined) {\n viewIndex = embeddedViews.length;\n }\n view.viewContainerParent = parentView;\n addToArray(embeddedViews, /** @type {?} */(( viewIndex)), view);\n const /** @type {?} */ dvcElementData = declaredViewContainer(view);\n if (dvcElementData && dvcElementData !== elementData) {\n let /** @type {?} */ projectedViews = dvcElementData.template._projectedViews;\n if (!projectedViews) {\n projectedViews = dvcElementData.template._projectedViews = [];\n }\n projectedViews.push(view);\n }\n\n Services.dirtyParentQueries(view);\n\n const /** @type {?} */ prevView = /** @type {?} */(( viewIndex)) > 0 ? embeddedViews[ /** @type {?} */((viewIndex)) - 1] : null;\n renderAttachEmbeddedView(elementData, prevView, view);\n}\n/**\n * @param {?} elementData\n * @param {?=} viewIndex\n * @return {?}\n */\nexport function detachEmbeddedView(elementData: ElementData, viewIndex?: number): ViewData|null {\n const /** @type {?} */ embeddedViews = /** @type {?} */(( elementData.viewContainer))._embeddedViews;\n if (viewIndex == null || viewIndex >= embeddedViews.length) {\n viewIndex = embeddedViews.length - 1;\n }\n if (viewIndex < 0) {\n return null;\n }\n const /** @type {?} */ view = embeddedViews[viewIndex];\n view.viewContainerParent = null;\n removeFromArray(embeddedViews, viewIndex);\n\n const /** @type {?} */ dvcElementData = declaredViewContainer(view);\n if (dvcElementData && dvcElementData !== elementData) {\n const /** @type {?} */ projectedViews = dvcElementData.template._projectedViews;\n removeFromArray(projectedViews, projectedViews.indexOf(view));\n }\n\n Services.dirtyParentQueries(view);\n\n renderDetachView(view);\n\n return view;\n}\n/**\n * @param {?} elementData\n * @param {?} oldViewIndex\n * @param {?} newViewIndex\n * @return {?}\n */\nexport function moveEmbeddedView(\n elementData: ElementData, oldViewIndex: number, newViewIndex: number): ViewData {\n const /** @type {?} */ embeddedViews = /** @type {?} */(( elementData.viewContainer))._embeddedViews;\n const /** @type {?} */ view = embeddedViews[oldViewIndex];\n removeFromArray(embeddedViews, oldViewIndex);\n if (newViewIndex == null) {\n newViewIndex = embeddedViews.length;\n }\n addToArray(embeddedViews, newViewIndex, view);\n\n // Note: Don't need to change projectedViews as the order in there\n // as always invalid...\n\n Services.dirtyParentQueries(view);\n\n renderDetachView(view);\n const /** @type {?} */ prevView = newViewIndex > 0 ? embeddedViews[newViewIndex - 1] : null;\n renderAttachEmbeddedView(elementData, prevView, view);\n\n return view;\n}\n/**\n * @param {?} elementData\n * @param {?} prevView\n * @param {?} view\n * @return {?}\n */\nfunction renderAttachEmbeddedView(\n elementData: ElementData, prevView: ViewData | null, view: ViewData) {\n const /** @type {?} */ prevRenderNode = prevView ? renderNode(prevView, /** @type {?} */(( prevView.def.lastRenderRootNode))) :\n elementData.renderElement;\n const /** @type {?} */ parentNode = view.renderer.parentNode(prevRenderNode);\n const /** @type {?} */ nextSibling = view.renderer.nextSibling(prevRenderNode);\n // Note: We can't check if `nextSibling` is present, as on WebWorkers it will always be!\n // However, browsers automatically do `appendChild` when there is no `nextSibling`.\n visitRootRenderNodes(view, RenderNodeAction.InsertBefore, parentNode, nextSibling, undefined);\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function renderDetachView(view: ViewData) {\n visitRootRenderNodes(view, RenderNodeAction.RemoveChild, null, null, undefined);\n}\n/**\n * @param {?} arr\n * @param {?} index\n * @param {?} value\n * @return {?}\n */\nfunction addToArray(arr: any[], index: number, value: any) {\n // perf: array.push is faster than array.splice!\n if (index >= arr.length) {\n arr.push(value);\n } else {\n arr.splice(index, 0, value);\n }\n}\n/**\n * @param {?} arr\n * @param {?} index\n * @return {?}\n */\nfunction removeFromArray(arr: any[], index: number) {\n // perf: array.pop is faster than array.splice!\n if (index >= arr.length - 1) {\n arr.pop();\n } else {\n arr.splice(index, 1);\n }\n}\n","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n\nimport {ChangeDetectorRef, SimpleChange, SimpleChanges, WrappedValue} from '../change_detection/change_detection';\nimport {Injector} from '../di';\nimport {ElementRef} from '../linker/element_ref';\nimport {TemplateRef} from '../linker/template_ref';\nimport {ViewContainerRef} from '../linker/view_container_ref';\nimport {Renderer as RendererV1, Renderer2} from '../render/api';\n\nimport {createChangeDetectorRef, createInjector, createRendererV1} from './refs';\nimport {BindingDef, BindingFlags, DepDef, DepFlags, NodeDef, NodeFlags, OutputDef, OutputType, ProviderData, QueryValueType, Services, ViewData, ViewFlags, ViewState, asElementData, asProviderData} from './types';\nimport {calcBindingFlags, checkBinding, dispatchEvent, isComponentView, splitMatchedQueriesDsl, tokenKey, viewParentEl} from './util';\n\nconst /** @type {?} */ RendererV1TokenKey = tokenKey(RendererV1);\nconst /** @type {?} */ Renderer2TokenKey = tokenKey(Renderer2);\nconst /** @type {?} */ ElementRefTokenKey = tokenKey(ElementRef);\nconst /** @type {?} */ ViewContainerRefTokenKey = tokenKey(ViewContainerRef);\nconst /** @type {?} */ TemplateRefTokenKey = tokenKey(TemplateRef);\nconst /** @type {?} */ ChangeDetectorRefTokenKey = tokenKey(ChangeDetectorRef);\nconst /** @type {?} */ InjectorRefTokenKey = tokenKey(Injector);\n\nconst /** @type {?} */ NOT_CREATED = new Object();\n/**\n * @param {?} flags\n * @param {?} matchedQueries\n * @param {?} childCount\n * @param {?} ctor\n * @param {?} deps\n * @param {?=} props\n * @param {?=} outputs\n * @return {?}\n */\nexport function directiveDef(\n flags: NodeFlags, matchedQueries: [string | number, QueryValueType][], childCount: number,\n ctor: any, deps: ([DepFlags, any] | any)[], props?: {[name: string]: [number, string]},\n outputs?: {[name: string]: string}): NodeDef {\n const /** @type {?} */ bindings: BindingDef[] = [];\n if (props) {\n for (let /** @type {?} */ prop in props) {\n const [bindingIndex, nonMinifiedName] = props[prop];\n bindings[bindingIndex] = {\n flags: BindingFlags.TypeProperty,\n name: prop, nonMinifiedName,\n ns: null,\n securityContext: null,\n suffix: null\n };\n }\n }\n const /** @type {?} */ outputDefs: OutputDef[] = [];\n if (outputs) {\n for (let /** @type {?} */ propName in outputs) {\n outputDefs.push(\n {type: OutputType.DirectiveOutput, propName, target: null, eventName: outputs[propName]});\n }\n }\n flags |= NodeFlags.TypeDirective;\n return _def(flags, matchedQueries, childCount, ctor, ctor, deps, bindings, outputDefs);\n}\n/**\n * @param {?} flags\n * @param {?} ctor\n * @param {?} deps\n * @return {?}\n */\nexport function pipeDef(flags: NodeFlags, ctor: any, deps: ([DepFlags, any] | any)[]): NodeDef {\n flags |= NodeFlags.TypePipe;\n return _def(flags, null, 0, ctor, ctor, deps);\n}\n/**\n * @param {?} flags\n * @param {?} matchedQueries\n * @param {?} token\n * @param {?} value\n * @param {?} deps\n * @return {?}\n */\nexport function providerDef(\n flags: NodeFlags, matchedQueries: [string | number, QueryValueType][], token: any, value: any,\n deps: ([DepFlags, any] | any)[]): NodeDef {\n return _def(flags, matchedQueries, 0, token, value, deps);\n}\n/**\n * @param {?} flags\n * @param {?} matchedQueriesDsl\n * @param {?} childCount\n * @param {?} token\n * @param {?} value\n * @param {?} deps\n * @param {?=} bindings\n * @param {?=} outputs\n * @return {?}\n */\nexport function _def(\n flags: NodeFlags, matchedQueriesDsl: [string | number, QueryValueType][] | null,\n childCount: number, token: any, value: any, deps: ([DepFlags, any] | any)[],\n bindings?: BindingDef[], outputs?: OutputDef[]): NodeDef {\n const {matchedQueries, references, matchedQueryIds} = splitMatchedQueriesDsl(matchedQueriesDsl);\n if (!outputs) {\n outputs = [];\n }\n if (!bindings) {\n bindings = [];\n }\n\n const /** @type {?} */ depDefs: DepDef[] = deps.map(value => {\n let /** @type {?} */ token: any;\n let /** @type {?} */ flags: DepFlags;\n if (Array.isArray(value)) {\n [flags, token] = value;\n } else {\n flags = DepFlags.None;\n token = value;\n }\n return {flags, token, tokenKey: tokenKey(token)};\n });\n\n return {\n // will bet set by the view definition\n index: -1,\n parent: null,\n renderParent: null,\n bindingIndex: -1,\n outputIndex: -1,\n // regular values\n flags,\n childFlags: 0,\n directChildFlags: 0,\n childMatchedQueries: 0, matchedQueries, matchedQueryIds, references,\n ngContentIndex: -1, childCount, bindings,\n bindingFlags: calcBindingFlags(bindings), outputs,\n element: null,\n provider: {token, tokenKey: tokenKey(token), value, deps: depDefs},\n text: null,\n query: null,\n ngContent: null\n };\n}\n/**\n * @param {?} view\n * @param {?} def\n * @return {?}\n */\nexport function createProviderInstance(view: ViewData, def: NodeDef): any {\n return def.flags & NodeFlags.LazyProvider ? NOT_CREATED : _createProviderInstance(view, def);\n}\n/**\n * @param {?} view\n * @param {?} def\n * @return {?}\n */\nexport function createPipeInstance(view: ViewData, def: NodeDef): any {\n // deps are looked up from component.\n let /** @type {?} */ compView = view;\n while (compView.parent && !isComponentView(compView)) {\n compView = compView.parent;\n }\n // pipes can see the private services of the component\n const /** @type {?} */ allowPrivateServices = true;\n // pipes are always eager and classes!\n return createClass( /** @type {?} */((\n compView.parent)), /** @type {?} */(( viewParentEl(compView))), allowPrivateServices, /** @type {?} */(( def.provider)).value, /** @type {?} */((\n def.provider)).deps);\n}\n/**\n * @param {?} view\n * @param {?} def\n * @return {?}\n */\nexport function createDirectiveInstance(view: ViewData, def: NodeDef): any {\n // components can see other private services, other directives can't.\n const /** @type {?} */ allowPrivateServices = (def.flags & NodeFlags.Component) > 0;\n // directives are always eager and classes!\n const /** @type {?} */ instance = createClass(\n view, /** @type {?} */(( def.parent)), allowPrivateServices, /** @type {?} */(( def.provider)).value, /** @type {?} */(( def.provider)).deps);\n if (def.outputs.length) {\n for (let /** @type {?} */ i = 0; i < def.outputs.length; i++) {\n const /** @type {?} */ output = def.outputs[i];\n const /** @type {?} */ subscription = instance[ /** @type {?} */((output.propName))].subscribe(\n eventHandlerClosure(view, /** @type {?} */(( def.parent)).index, output.eventName)); /** @type {?} */((\n view.disposables))[def.outputIndex + i] = subscription.unsubscribe.bind(subscription);\n }\n }\n return instance;\n}\n/**\n * @param {?} view\n * @param {?} index\n * @param {?} eventName\n * @return {?}\n */\nfunction eventHandlerClosure(view: ViewData, index: number, eventName: string) {\n return (event: any) => {\n try {\n return dispatchEvent(view, index, eventName, event);\n } catch ( /** @type {?} */e) {\n // Attention: Don't rethrow, as it would cancel Observable subscriptions!\n view.root.errorHandler.handleError(e);\n }\n }\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} v0\n * @param {?} v1\n * @param {?} v2\n * @param {?} v3\n * @param {?} v4\n * @param {?} v5\n * @param {?} v6\n * @param {?} v7\n * @param {?} v8\n * @param {?} v9\n * @return {?}\n */\nexport function checkAndUpdateDirectiveInline(\n view: ViewData, def: NodeDef, v0: any, v1: any, v2: any, v3: any, v4: any, v5: any, v6: any,\n v7: any, v8: any, v9: any): boolean {\n const /** @type {?} */ providerData = asProviderData(view, def.index);\n const /** @type {?} */ directive = providerData.instance;\n let /** @type {?} */ changed = false;\n let /** @type {?} */ changes: SimpleChanges = /** @type {?} */(( undefined));\n const /** @type {?} */ bindLen = def.bindings.length;\n if (bindLen > 0 && checkBinding(view, def, 0, v0)) {\n changed = true;\n changes = updateProp(view, providerData, def, 0, v0, changes);\n }\n if (bindLen > 1 && checkBinding(view, def, 1, v1)) {\n changed = true;\n changes = updateProp(view, providerData, def, 1, v1, changes);\n }\n if (bindLen > 2 && checkBinding(view, def, 2, v2)) {\n changed = true;\n changes = updateProp(view, providerData, def, 2, v2, changes);\n }\n if (bindLen > 3 && checkBinding(view, def, 3, v3)) {\n changed = true;\n changes = updateProp(view, providerData, def, 3, v3, changes);\n }\n if (bindLen > 4 && checkBinding(view, def, 4, v4)) {\n changed = true;\n changes = updateProp(view, providerData, def, 4, v4, changes);\n }\n if (bindLen > 5 && checkBinding(view, def, 5, v5)) {\n changed = true;\n changes = updateProp(view, providerData, def, 5, v5, changes);\n }\n if (bindLen > 6 && checkBinding(view, def, 6, v6)) {\n changed = true;\n changes = updateProp(view, providerData, def, 6, v6, changes);\n }\n if (bindLen > 7 && checkBinding(view, def, 7, v7)) {\n changed = true;\n changes = updateProp(view, providerData, def, 7, v7, changes);\n }\n if (bindLen > 8 && checkBinding(view, def, 8, v8)) {\n changed = true;\n changes = updateProp(view, providerData, def, 8, v8, changes);\n }\n if (bindLen > 9 && checkBinding(view, def, 9, v9)) {\n changed = true;\n changes = updateProp(view, providerData, def, 9, v9, changes);\n }\n if (changes) {\n directive.ngOnChanges(changes);\n }\n if ((view.state & ViewState.FirstCheck) && (def.flags & NodeFlags.OnInit)) {\n directive.ngOnInit();\n }\n if (def.flags & NodeFlags.DoCheck) {\n directive.ngDoCheck();\n }\n return changed;\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} values\n * @return {?}\n */\nexport function checkAndUpdateDirectiveDynamic(\n view: ViewData, def: NodeDef, values: any[]): boolean {\n const /** @type {?} */ providerData = asProviderData(view, def.index);\n const /** @type {?} */ directive = providerData.instance;\n let /** @type {?} */ changed = false;\n let /** @type {?} */ changes: SimpleChanges = /** @type {?} */(( undefined));\n for (let /** @type {?} */ i = 0; i < values.length; i++) {\n if (checkBinding(view, def, i, values[i])) {\n changed = true;\n changes = updateProp(view, providerData, def, i, values[i], changes);\n }\n }\n if (changes) {\n directive.ngOnChanges(changes);\n }\n if ((view.state & ViewState.FirstCheck) && (def.flags & NodeFlags.OnInit)) {\n directive.ngOnInit();\n }\n if (def.flags & NodeFlags.DoCheck) {\n directive.ngDoCheck();\n }\n return changed;\n}\n/**\n * @param {?} view\n * @param {?} def\n * @return {?}\n */\nfunction _createProviderInstance(view: ViewData, def: NodeDef): any {\n // private services can see other private services\n const /** @type {?} */ allowPrivateServices = (def.flags & NodeFlags.PrivateProvider) > 0;\n const /** @type {?} */ providerDef = def.provider;\n let /** @type {?} */ injectable: any;\n switch (def.flags & NodeFlags.Types) {\n case NodeFlags.TypeClassProvider:\n injectable = createClass(\n view, /** @type {?} */(( def.parent)), allowPrivateServices, /** @type {?} */(( providerDef)).value, /** @type {?} */(( providerDef)).deps);\n break;\n case NodeFlags.TypeFactoryProvider:\n injectable = callFactory(\n view, /** @type {?} */(( def.parent)), allowPrivateServices, /** @type {?} */(( providerDef)).value, /** @type {?} */(( providerDef)).deps);\n break;\n case NodeFlags.TypeUseExistingProvider:\n injectable = resolveDep(view, /** @type {?} */(( def.parent)), allowPrivateServices, /** @type {?} */(( providerDef)).deps[0]);\n break;\n case NodeFlags.TypeValueProvider:\n injectable = /** @type {?} */(( providerDef)).value;\n break;\n }\n return injectable;\n}\n/**\n * @param {?} view\n * @param {?} elDef\n * @param {?} allowPrivateServices\n * @param {?} ctor\n * @param {?} deps\n * @return {?}\n */\nfunction createClass(\n view: ViewData, elDef: NodeDef, allowPrivateServices: boolean, ctor: any, deps: DepDef[]): any {\n const /** @type {?} */ len = deps.length;\n let /** @type {?} */ injectable: any;\n switch (len) {\n case 0:\n injectable = new ctor();\n break;\n case 1:\n injectable = new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]));\n break;\n case 2:\n injectable = new ctor(\n resolveDep(view, elDef, allowPrivateServices, deps[0]),\n resolveDep(view, elDef, allowPrivateServices, deps[1]));\n break;\n case 3:\n injectable = new ctor(\n resolveDep(view, elDef, allowPrivateServices, deps[0]),\n resolveDep(view, elDef, allowPrivateServices, deps[1]),\n resolveDep(view, elDef, allowPrivateServices, deps[2]));\n break;\n default:\n const /** @type {?} */ depValues = new Array(len);\n for (let /** @type {?} */ i = 0; i < len; i++) {\n depValues[i] = resolveDep(view, elDef, allowPrivateServices, deps[i]);\n }\n injectable = new ctor(...depValues);\n }\n return injectable;\n}\n/**\n * @param {?} view\n * @param {?} elDef\n * @param {?} allowPrivateServices\n * @param {?} factory\n * @param {?} deps\n * @return {?}\n */\nfunction callFactory(\n view: ViewData, elDef: NodeDef, allowPrivateServices: boolean, factory: any,\n deps: DepDef[]): any {\n const /** @type {?} */ len = deps.length;\n let /** @type {?} */ injectable: any;\n switch (len) {\n case 0:\n injectable = factory();\n break;\n case 1:\n injectable = factory(resolveDep(view, elDef, allowPrivateServices, deps[0]));\n break;\n case 2:\n injectable = factory(\n resolveDep(view, elDef, allowPrivateServices, deps[0]),\n resolveDep(view, elDef, allowPrivateServices, deps[1]));\n break;\n case 3:\n injectable = factory(\n resolveDep(view, elDef, allowPrivateServices, deps[0]),\n resolveDep(view, elDef, allowPrivateServices, deps[1]),\n resolveDep(view, elDef, allowPrivateServices, deps[2]));\n break;\n default:\n const /** @type {?} */ depValues = Array(len);\n for (let /** @type {?} */ i = 0; i < len; i++) {\n depValues[i] = resolveDep(view, elDef, allowPrivateServices, deps[i]);\n }\n injectable = factory(...depValues);\n }\n return injectable;\n}\n\n// This default value is when checking the hierarchy for a token.\n//\n// It means both:\n// - the token is not provided by the current injector,\n// - only the element injectors should be checked (ie do not check module injectors\n//\n// mod1\n// /\n// el1 mod2\n// \\ /\n// el2\n//\n// When requesting el2.injector.get(token), we should check in the following order and return the\n// first found value:\n// - el2.injector.get(token, default)\n// - el1.injector.get(token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) -> do not check the module\n// - mod2.injector.get(token, default)\nexport const /** @type {?} */ NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};\n/**\n * @param {?} view\n * @param {?} elDef\n * @param {?} allowPrivateServices\n * @param {?} depDef\n * @param {?=} notFoundValue\n * @return {?}\n */\nexport function resolveDep(\n view: ViewData, elDef: NodeDef, allowPrivateServices: boolean, depDef: DepDef,\n notFoundValue: any = Injector.THROW_IF_NOT_FOUND): any {\n if (depDef.flags & DepFlags.Value) {\n return depDef.token;\n }\n const /** @type {?} */ startView = view;\n if (depDef.flags & DepFlags.Optional) {\n notFoundValue = null;\n }\n const /** @type {?} */ tokenKey = depDef.tokenKey;\n\n if (tokenKey === ChangeDetectorRefTokenKey) {\n // directives on the same element as a component should be able to control the change detector\n // of that component as well.\n allowPrivateServices = !!(elDef && /** @type {?} */(( elDef.element)).componentView);\n }\n\n if (elDef && (depDef.flags & DepFlags.SkipSelf)) {\n allowPrivateServices = false;\n elDef = /** @type {?} */(( elDef.parent));\n }\n\n while (view) {\n if (elDef) {\n switch (tokenKey) {\n case RendererV1TokenKey: {\n const /** @type {?} */ compView = findCompView(view, elDef, allowPrivateServices);\n return createRendererV1(compView);\n }\n case Renderer2TokenKey: {\n const /** @type {?} */ compView = findCompView(view, elDef, allowPrivateServices);\n return compView.renderer;\n }\n case ElementRefTokenKey:\n return new ElementRef(asElementData(view, elDef.index).renderElement);\n case ViewContainerRefTokenKey:\n return asElementData(view, elDef.index).viewContainer;\n case TemplateRefTokenKey: {\n if ( /** @type {?} */((elDef.element)).template) {\n return asElementData(view, elDef.index).template;\n }\n break;\n }\n case ChangeDetectorRefTokenKey: {\n let /** @type {?} */ cdView = findCompView(view, elDef, allowPrivateServices);\n return createChangeDetectorRef(cdView);\n }\n case InjectorRefTokenKey:\n return createInjector(view, elDef);\n default:\n const /** @type {?} */ providerDef = /** @type {?} */((\n (allowPrivateServices ? /** @type {?} */(( elDef.element)).allProviders : /** @type {?} */((\n elDef.element)).publicProviders)))[tokenKey];\n if (providerDef) {\n const /** @type {?} */ providerData = asProviderData(view, providerDef.index);\n if (providerData.instance === NOT_CREATED) {\n providerData.instance = _createProviderInstance(view, providerDef);\n }\n return providerData.instance;\n }\n }\n }\n allowPrivateServices = isComponentView(view);\n elDef = /** @type {?} */(( viewParentEl(view)));\n view = /** @type {?} */(( view.parent));\n }\n\n const /** @type {?} */ value = startView.root.injector.get(depDef.token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR);\n\n if (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR ||\n notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) {\n // Return the value from the root element injector when\n // - it provides it\n // (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)\n // - the module injector should not be checked\n // (notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)\n return value;\n }\n\n return startView.root.ngModule.injector.get(depDef.token, notFoundValue);\n}\n/**\n * @param {?} view\n * @param {?} elDef\n * @param {?} allowPrivateServices\n * @return {?}\n */\nfunction findCompView(view: ViewData, elDef: NodeDef, allowPrivateServices: boolean) {\n let /** @type {?} */ compView: ViewData;\n if (allowPrivateServices) {\n compView = asElementData(view, elDef.index).componentView;\n } else {\n compView = view;\n while (compView.parent && !isComponentView(compView)) {\n compView = compView.parent;\n }\n }\n return compView;\n}\n/**\n * @param {?} view\n * @param {?} providerData\n * @param {?} def\n * @param {?} bindingIdx\n * @param {?} value\n * @param {?} changes\n * @return {?}\n */\nfunction updateProp(\n view: ViewData, providerData: ProviderData, def: NodeDef, bindingIdx: number, value: any,\n changes: SimpleChanges): SimpleChanges {\n if (def.flags & NodeFlags.Component) {\n const /** @type {?} */ compView = asElementData(view, /** @type {?} */(( def.parent)).index).componentView;\n if (compView.def.flags & ViewFlags.OnPush) {\n compView.state |= ViewState.ChecksEnabled;\n }\n }\n const /** @type {?} */ binding = def.bindings[bindingIdx];\n const /** @type {?} */ propName = /** @type {?} */(( binding.name));\n // Note: This is still safe with Closure Compiler as\n // the user passed in the property name as an object has to `providerDef`,\n // so Closure Compiler will have renamed the property correctly already.\n providerData.instance[propName] = value;\n if (def.flags & NodeFlags.OnChanges) {\n changes = changes || {};\n let /** @type {?} */ oldValue = view.oldValues[def.bindingIndex + bindingIdx];\n if (oldValue instanceof WrappedValue) {\n oldValue = oldValue.wrapped;\n }\n const /** @type {?} */ binding = def.bindings[bindingIdx];\n changes[ /** @type {?} */((binding.nonMinifiedName))] =\n new SimpleChange(oldValue, value, (view.state & ViewState.FirstCheck) !== 0);\n }\n view.oldValues[def.bindingIndex + bindingIdx] = value;\n return changes;\n}\n/**\n * @param {?} view\n * @param {?} lifecycles\n * @return {?}\n */\nexport function callLifecycleHooksChildrenFirst(view: ViewData, lifecycles: NodeFlags) {\n if (!(view.def.nodeFlags & lifecycles)) {\n return;\n }\n const /** @type {?} */ nodes = view.def.nodes;\n for (let /** @type {?} */ i = 0; i < nodes.length; i++) {\n const /** @type {?} */ nodeDef = nodes[i];\n let /** @type {?} */ parent = nodeDef.parent;\n if (!parent && nodeDef.flags & lifecycles) {\n // matching root node (e.g. a pipe)\n callProviderLifecycles(view, i, nodeDef.flags & lifecycles);\n }\n if ((nodeDef.childFlags & lifecycles) === 0) {\n // no child matches one of the lifecycles\n i += nodeDef.childCount;\n }\n while (parent && (parent.flags & NodeFlags.TypeElement) &&\n i === parent.index + parent.childCount) {\n // last child of an element\n if (parent.directChildFlags & lifecycles) {\n callElementProvidersLifecycles(view, parent, lifecycles);\n }\n parent = parent.parent;\n }\n }\n}\n/**\n * @param {?} view\n * @param {?} elDef\n * @param {?} lifecycles\n * @return {?}\n */\nfunction callElementProvidersLifecycles(view: ViewData, elDef: NodeDef, lifecycles: NodeFlags) {\n for (let /** @type {?} */ i = elDef.index + 1; i <= elDef.index + elDef.childCount; i++) {\n const /** @type {?} */ nodeDef = view.def.nodes[i];\n if (nodeDef.flags & lifecycles) {\n callProviderLifecycles(view, i, nodeDef.flags & lifecycles);\n }\n // only visit direct children\n i += nodeDef.childCount;\n }\n}\n/**\n * @param {?} view\n * @param {?} index\n * @param {?} lifecycles\n * @return {?}\n */\nfunction callProviderLifecycles(view: ViewData, index: number, lifecycles: NodeFlags) {\n const /** @type {?} */ provider = asProviderData(view, index).instance;\n if (provider === NOT_CREATED) {\n return;\n }\n Services.setCurrentNode(view, index);\n if (lifecycles & NodeFlags.AfterContentInit) {\n provider.ngAfterContentInit();\n }\n if (lifecycles & NodeFlags.AfterContentChecked) {\n provider.ngAfterContentChecked();\n }\n if (lifecycles & NodeFlags.AfterViewInit) {\n provider.ngAfterViewInit();\n }\n if (lifecycles & NodeFlags.AfterViewChecked) {\n provider.ngAfterViewChecked();\n }\n if (lifecycles & NodeFlags.OnDestroy) {\n provider.ngOnDestroy();\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 {NodeDef, NodeFlags, ViewData} from './types';\nimport {RenderNodeAction, getParentRenderElement, visitProjectedRenderNodes} from './util';\n/**\n * @param {?} ngContentIndex\n * @param {?} index\n * @return {?}\n */\nexport function ngContentDef(ngContentIndex: number, index: number): NodeDef {\n return {\n // will bet set by the view definition\n index: -1,\n parent: null,\n renderParent: null,\n bindingIndex: -1,\n outputIndex: -1,\n // regular values\n flags: NodeFlags.TypeNgContent,\n childFlags: 0,\n directChildFlags: 0,\n childMatchedQueries: 0,\n matchedQueries: {},\n matchedQueryIds: 0,\n references: {}, ngContentIndex,\n childCount: 0,\n bindings: [],\n bindingFlags: 0,\n outputs: [],\n element: null,\n provider: null,\n text: null,\n query: null,\n ngContent: {index}\n };\n}\n/**\n * @param {?} view\n * @param {?} renderHost\n * @param {?} def\n * @return {?}\n */\nexport function appendNgContent(view: ViewData, renderHost: any, def: NodeDef) {\n const /** @type {?} */ parentEl = getParentRenderElement(view, renderHost, def);\n if (!parentEl) {\n // Nothing to do if there is no parent element.\n return;\n }\n const /** @type {?} */ ngContentIndex = /** @type {?} */(( def.ngContent)).index;\n visitProjectedRenderNodes(\n view, ngContentIndex, RenderNodeAction.AppendChild, parentEl, null, undefined);\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 {RendererType2} from '../render/api';\nimport {SecurityContext} from '../security';\n\nimport {BindingDef, BindingFlags, ElementData, ElementHandleEventFn, NodeDef, NodeFlags, OutputDef, OutputType, QueryValueType, ViewData, ViewDefinitionFactory, asElementData} from './types';\nimport {NOOP, calcBindingFlags, checkAndUpdateBinding, dispatchEvent, elementEventFullName, getParentRenderElement, resolveRendererType2, resolveViewDefinition, splitMatchedQueriesDsl, splitNamespace} from './util';\n/**\n * @param {?} flags\n * @param {?} matchedQueriesDsl\n * @param {?} ngContentIndex\n * @param {?} childCount\n * @param {?=} handleEvent\n * @param {?=} templateFactory\n * @return {?}\n */\nexport function anchorDef(\n flags: NodeFlags, matchedQueriesDsl: [string | number, QueryValueType][],\n ngContentIndex: number, childCount: number, handleEvent?: ElementHandleEventFn,\n templateFactory?: ViewDefinitionFactory): NodeDef {\n flags |= NodeFlags.TypeElement;\n const {matchedQueries, references, matchedQueryIds} = splitMatchedQueriesDsl(matchedQueriesDsl);\n const /** @type {?} */ template = templateFactory ? resolveViewDefinition(templateFactory) : null;\n\n return {\n // will bet set by the view definition\n index: -1,\n parent: null,\n renderParent: null,\n bindingIndex: -1,\n outputIndex: -1,\n // regular values\n flags,\n childFlags: 0,\n directChildFlags: 0,\n childMatchedQueries: 0, matchedQueries, matchedQueryIds, references, ngContentIndex, childCount,\n bindings: [],\n bindingFlags: 0,\n outputs: [],\n element: {\n ns: null,\n name: null,\n attrs: null, template,\n componentProvider: null,\n componentView: null,\n componentRendererType: null,\n publicProviders: null,\n allProviders: null,\n handleEvent: handleEvent || NOOP\n },\n provider: null,\n text: null,\n query: null,\n ngContent: null\n };\n}\n/**\n * @param {?} flags\n * @param {?} matchedQueriesDsl\n * @param {?} ngContentIndex\n * @param {?} childCount\n * @param {?} namespaceAndName\n * @param {?=} fixedAttrs\n * @param {?=} bindings\n * @param {?=} outputs\n * @param {?=} handleEvent\n * @param {?=} componentView\n * @param {?=} componentRendererType\n * @return {?}\n */\nexport function elementDef(\n flags: NodeFlags, matchedQueriesDsl: [string | number, QueryValueType][],\n ngContentIndex: number, childCount: number, namespaceAndName: string,\n fixedAttrs: [string, string][] = [],\n bindings?: [BindingFlags, string, string | SecurityContext][], outputs?: ([string, string])[],\n handleEvent?: ElementHandleEventFn, componentView?: ViewDefinitionFactory,\n componentRendererType?: RendererType2 | null): NodeDef {\n if (!handleEvent) {\n handleEvent = NOOP;\n }\n const {matchedQueries, references, matchedQueryIds} = splitMatchedQueriesDsl(matchedQueriesDsl);\n let /** @type {?} */ ns: string = /** @type {?} */(( null));\n let /** @type {?} */ name: string = /** @type {?} */(( null));\n if (namespaceAndName) {\n [ns, name] = splitNamespace(namespaceAndName);\n }\n bindings = bindings || [];\n const /** @type {?} */ bindingDefs: BindingDef[] = new Array(bindings.length);\n for (let /** @type {?} */ i = 0; i < bindings.length; i++) {\n const [bindingFlags, namespaceAndName, suffixOrSecurityContext] = bindings[i];\n\n const [ns, name] = splitNamespace(namespaceAndName);\n let /** @type {?} */ securityContext: SecurityContext = /** @type {?} */(( undefined));\n let /** @type {?} */ suffix: string = /** @type {?} */(( undefined));\n switch (bindingFlags & BindingFlags.Types) {\n case BindingFlags.TypeElementStyle:\n suffix = /** @type {?} */(( <string>suffixOrSecurityContext));\n break;\n case BindingFlags.TypeElementAttribute:\n case BindingFlags.TypeProperty:\n securityContext = /** @type {?} */(( <SecurityContext>suffixOrSecurityContext));\n break;\n }\n bindingDefs[i] =\n {flags: bindingFlags, ns, name, nonMinifiedName: name, securityContext, suffix};\n }\n outputs = outputs || [];\n const /** @type {?} */ outputDefs: OutputDef[] = new Array(outputs.length);\n for (let /** @type {?} */ i = 0; i < outputs.length; i++) {\n const [target, eventName] = outputs[i];\n outputDefs[i] = {\n type: OutputType.ElementOutput,\n target: /** @type {?} */(( <any>target)), eventName,\n propName: null\n };\n }\n fixedAttrs = fixedAttrs || [];\n const /** @type {?} */ attrs = /** @type {?} */(( <[string, string, string][]>fixedAttrs.map(([namespaceAndName, value]) => {\n const [ns, name] = splitNamespace(namespaceAndName);\n return [ns, name, value];\n })));\n componentRendererType = resolveRendererType2(componentRendererType);\n if (componentView) {\n flags |= NodeFlags.ComponentView;\n }\n flags |= NodeFlags.TypeElement;\n return {\n // will bet set by the view definition\n index: -1,\n parent: null,\n renderParent: null,\n bindingIndex: -1,\n outputIndex: -1,\n // regular values\n flags,\n childFlags: 0,\n directChildFlags: 0,\n childMatchedQueries: 0, matchedQueries, matchedQueryIds, references, ngContentIndex, childCount,\n bindings: bindingDefs,\n bindingFlags: calcBindingFlags(bindingDefs),\n outputs: outputDefs,\n element: {\n ns,\n name,\n attrs,\n template: null,\n // will bet set by the view definition\n componentProvider: null,\n componentView: componentView || null,\n componentRendererType: componentRendererType,\n publicProviders: null,\n allProviders: null,\n handleEvent: handleEvent || NOOP,\n },\n provider: null,\n text: null,\n query: null,\n ngContent: null\n };\n}\n/**\n * @param {?} view\n * @param {?} renderHost\n * @param {?} def\n * @return {?}\n */\nexport function createElement(view: ViewData, renderHost: any, def: NodeDef): ElementData {\n const /** @type {?} */ elDef = /** @type {?} */(( def.element));\n const /** @type {?} */ rootSelectorOrNode = view.root.selectorOrNode;\n const /** @type {?} */ renderer = view.renderer;\n let /** @type {?} */ el: any;\n if (view.parent || !rootSelectorOrNode) {\n if (elDef.name) {\n el = renderer.createElement(elDef.name, elDef.ns);\n } else {\n el = renderer.createComment('');\n }\n const /** @type {?} */ parentEl = getParentRenderElement(view, renderHost, def);\n if (parentEl) {\n renderer.appendChild(parentEl, el);\n }\n } else {\n el = renderer.selectRootElement(rootSelectorOrNode);\n }\n if (elDef.attrs) {\n for (let /** @type {?} */ i = 0; i < elDef.attrs.length; i++) {\n const [ns, name, value] = elDef.attrs[i];\n renderer.setAttribute(el, name, value, ns);\n }\n }\n return el;\n}\n/**\n * @param {?} view\n * @param {?} compView\n * @param {?} def\n * @param {?} el\n * @return {?}\n */\nexport function listenToElementOutputs(view: ViewData, compView: ViewData, def: NodeDef, el: any) {\n for (let /** @type {?} */ i = 0; i < def.outputs.length; i++) {\n const /** @type {?} */ output = def.outputs[i];\n const /** @type {?} */ handleEventClosure = renderEventHandlerClosure(\n view, def.index, elementEventFullName(output.target, output.eventName));\n let /** @type {?} */ listenTarget: 'window'|'document'|'body'|'component'|null = output.target;\n let /** @type {?} */ listenerView = view;\n if (output.target === 'component') {\n listenTarget = null;\n listenerView = compView;\n }\n const /** @type {?} */ disposable = /** @type {?} */((\n <any>listenerView.renderer.listen(listenTarget || el, output.eventName, handleEventClosure))); /** @type {?} */((\n view.disposables))[def.outputIndex + i] = disposable;\n }\n}\n/**\n * @param {?} view\n * @param {?} index\n * @param {?} eventName\n * @return {?}\n */\nfunction renderEventHandlerClosure(view: ViewData, index: number, eventName: string) {\n return (event: any) => {\n try {\n return dispatchEvent(view, index, eventName, event);\n } catch ( /** @type {?} */e) {\n // Attention: Don't rethrow, to keep in sync with directive events.\n view.root.errorHandler.handleError(e);\n }\n }\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} v0\n * @param {?} v1\n * @param {?} v2\n * @param {?} v3\n * @param {?} v4\n * @param {?} v5\n * @param {?} v6\n * @param {?} v7\n * @param {?} v8\n * @param {?} v9\n * @return {?}\n */\nexport function checkAndUpdateElementInline(\n view: ViewData, def: NodeDef, v0: any, v1: any, v2: any, v3: any, v4: any, v5: any, v6: any,\n v7: any, v8: any, v9: any): boolean {\n const /** @type {?} */ bindLen = def.bindings.length;\n let /** @type {?} */ changed = false;\n if (bindLen > 0 && checkAndUpdateElementValue(view, def, 0, v0)) changed = true;\n if (bindLen > 1 && checkAndUpdateElementValue(view, def, 1, v1)) changed = true;\n if (bindLen > 2 && checkAndUpdateElementValue(view, def, 2, v2)) changed = true;\n if (bindLen > 3 && checkAndUpdateElementValue(view, def, 3, v3)) changed = true;\n if (bindLen > 4 && checkAndUpdateElementValue(view, def, 4, v4)) changed = true;\n if (bindLen > 5 && checkAndUpdateElementValue(view, def, 5, v5)) changed = true;\n if (bindLen > 6 && checkAndUpdateElementValue(view, def, 6, v6)) changed = true;\n if (bindLen > 7 && checkAndUpdateElementValue(view, def, 7, v7)) changed = true;\n if (bindLen > 8 && checkAndUpdateElementValue(view, def, 8, v8)) changed = true;\n if (bindLen > 9 && checkAndUpdateElementValue(view, def, 9, v9)) changed = true;\n return changed;\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} values\n * @return {?}\n */\nexport function checkAndUpdateElementDynamic(view: ViewData, def: NodeDef, values: any[]): boolean {\n let /** @type {?} */ changed = false;\n for (let /** @type {?} */ i = 0; i < values.length; i++) {\n if (checkAndUpdateElementValue(view, def, i, values[i])) changed = true;\n }\n return changed;\n}\n/**\n * @param {?} view\n * @param {?} def\n * @param {?} bindingIdx\n * @param {?} value\n * @return {?}\n */\nfunction checkAndUpdateElementValue(view: ViewData, def: NodeDef, bindingIdx: number, value: any) {\n if (!checkAndUpdateBinding(view, def, bindingIdx, value)) {\n return false;\n }\n const /** @type {?} */ binding = def.bindings[bindingIdx];\n const /** @type {?} */ elData = asElementData(view, def.index);\n const /** @type {?} */ renderNode = elData.renderElement;\n const /** @type {?} */ name = /** @type {?} */(( binding.name));\n switch (binding.flags & BindingFlags.Types) {\n case BindingFlags.TypeElementAttribute:\n setElementAttribute(view, binding, renderNode, binding.ns, name, value);\n break;\n case BindingFlags.TypeElementClass:\n setElementClass(view, renderNode, name, value);\n break;\n case BindingFlags.TypeElementStyle:\n setElementStyle(view, binding, renderNode, name, value);\n break;\n case BindingFlags.TypeProperty:\n const /** @type {?} */ bindView = (def.flags & NodeFlags.ComponentView &&\n binding.flags & BindingFlags.SyntheticHostProperty) ?\n elData.componentView :\n view;\n setElementProperty(bindView, binding, renderNode, name, value);\n break;\n }\n return true;\n}\n/**\n * @param {?} view\n * @param {?} binding\n * @param {?} renderNode\n * @param {?} ns\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\nfunction setElementAttribute(\n view: ViewData, binding: BindingDef, renderNode: any, ns: string | null, name: string,\n value: any) {\n const /** @type {?} */ securityContext = binding.securityContext;\n let /** @type {?} */ renderValue = securityContext ? view.root.sanitizer.sanitize(securityContext, value) : value;\n renderValue = renderValue != null ? renderValue.toString() : null;\n const /** @type {?} */ renderer = view.renderer;\n if (value != null) {\n renderer.setAttribute(renderNode, name, renderValue, ns);\n } else {\n renderer.removeAttribute(renderNode, name, ns);\n }\n}\n/**\n * @param {?} view\n * @param {?} renderNode\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\nfunction setElementClass(view: ViewData, renderNode: any, name: string, value: boolean) {\n const /** @type {?} */ renderer = view.renderer;\n if (value) {\n renderer.addClass(renderNode, name);\n } else {\n renderer.removeClass(renderNode, name);\n }\n}\n/**\n * @param {?} view\n * @param {?} binding\n * @param {?} renderNode\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\nfunction setElementStyle(\n view: ViewData, binding: BindingDef, renderNode: any, name: string, value: any) {\n let /** @type {?} */ renderValue: string|null =\n view.root.sanitizer.sanitize(SecurityContext.STYLE, /** @type {?} */(( value as{} | string)));\n if (renderValue != null) {\n renderValue = renderValue.toString();\n const /** @type {?} */ unit = binding.suffix;\n if (unit != null) {\n renderValue = renderValue + unit;\n }\n } else {\n renderValue = null;\n }\n const /** @type {?} */ renderer = view.renderer;\n if (renderValue != null) {\n renderer.setStyle(renderNode, name, renderValue);\n } else {\n renderer.removeStyle(renderNode, name);\n }\n}\n/**\n * @param {?} view\n * @param {?} binding\n * @param {?} renderNode\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\nfunction setElementProperty(\n view: ViewData, binding: BindingDef, renderNode: any, name: string, value: any) {\n const /** @type {?} */ securityContext = binding.securityContext;\n let /** @type {?} */ renderValue = securityContext ? view.root.sanitizer.sanitize(securityContext, value) : value;\n view.renderer.setProperty(renderNode, name, renderValue);\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 {PlatformRef, PlatformRef_, createPlatformFactory} from './application_ref';\nimport {PLATFORM_ID} from './application_tokens';\nimport {Console} from './console';\nimport {Provider} from './di';\nimport {Reflector, reflector} from './reflection/reflection';\nimport {ReflectorReader} from './reflection/reflector_reader';\nimport {TestabilityRegistry} from './testability/testability';\n/**\n * @return {?}\n */\nfunction _reflector(): Reflector {\n return reflector;\n}\n\nconst /** @type {?} */ _CORE_PLATFORM_PROVIDERS: Provider[] = [\n // Set a default platform name for platforms that don't set it explicitly.\n {provide: PLATFORM_ID, useValue: 'unknown'},\n PlatformRef_,\n {provide: PlatformRef, useExisting: PlatformRef_},\n {provide: Reflector, useFactory: _reflector, deps: []},\n {provide: ReflectorReader, useExisting: Reflector},\n TestabilityRegistry,\n Console,\n];\n/**\n * This platform has to be included in any other platform\n * \n * \\@experimental\n */\nexport const platformCore = createPlatformFactory(null, 'core', _CORE_PLATFORM_PROVIDERS);\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} from './ng_module_factory';\n/**\n * Used to load ng module factories.\n * \\@stable\n * @abstract\n */\nexport abstract class NgModuleFactoryLoader {\n/**\n * @abstract\n * @param {?} path\n * @return {?}\n */\nload(path: string) {}\n}\n\nlet /** @type {?} */ moduleFactories = new Map<string, NgModuleFactory<any>>();\n/**\n * Registers a loaded module. Should only be called from generated NgModuleFactory code.\n * \\@experimental\n * @param {?} id\n * @param {?} factory\n * @return {?}\n */\nexport function registerModuleFactory(id: string, factory: NgModuleFactory<any>) {\n const /** @type {?} */ existing = moduleFactories.get(id);\n if (existing) {\n throw new Error(`Duplicate module registered for ${id\n } - ${existing.moduleType.name} vs ${factory.moduleType.name}`);\n }\n moduleFactories.set(id, factory);\n}\n/**\n * @return {?}\n */\nexport function clearModulesForTest() {\n moduleFactories = new Map<string, NgModuleFactory<any>>();\n}\n/**\n * Returns the NgModuleFactory with the given id, if it exists and has been loaded.\n * Factories for modules that do not specify an `id` cannot be retrieved. Throws if the module\n * cannot be found.\n * \\@experimental\n * @param {?} id\n * @return {?}\n */\nexport function getModuleFactory(id: string): NgModuleFactory<any> {\n const /** @type {?} */ factory = moduleFactories.get(id);\n if (!factory) throw new Error(`No module with ID ${id} loaded`);\n return factory;\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 {wrappedError} from '../error_handler';\nimport {ERROR_ORIGINAL_ERROR, getOriginalError} from '../errors';\nimport {Type} from '../type';\nimport {stringify} from '../util';\n\nimport {ReflectiveInjector} from './reflective_injector';\nimport {ReflectiveKey} from './reflective_key';\n/**\n * @param {?} keys\n * @return {?}\n */\nfunction findFirstClosedCycle(keys: any[]): any[] {\n const /** @type {?} */ res: any[] = [];\n for (let /** @type {?} */ i = 0; i < keys.length; ++i) {\n if (res.indexOf(keys[i]) > -1) {\n res.push(keys[i]);\n return res;\n }\n res.push(keys[i]);\n }\n return res;\n}\n/**\n * @param {?} keys\n * @return {?}\n */\nfunction constructResolvingPath(keys: any[]): string {\n if (keys.length > 1) {\n const /** @type {?} */ reversed = findFirstClosedCycle(keys.slice().reverse());\n const /** @type {?} */ tokenStrs = reversed.map(k => stringify(k.token));\n return ' (' + tokenStrs.join(' -> ') + ')';\n }\n\n return '';\n}\n\nexport interface InjectionError extends Error {\n keys: ReflectiveKey[];\n injectors: ReflectiveInjector[];\n constructResolvingMessage: (this: InjectionError) => string;\n addKey(injector: ReflectiveInjector, key: ReflectiveKey): void;\n}\n/**\n * @param {?} injector\n * @param {?} key\n * @param {?} constructResolvingMessage\n * @param {?=} originalError\n * @return {?}\n */\nfunction injectionError(\n injector: ReflectiveInjector, key: ReflectiveKey,\n constructResolvingMessage: (this: InjectionError) => string,\n originalError?: Error): InjectionError {\n const /** @type {?} */ error = /** @type {?} */(( (originalError ? wrappedError('', originalError) : Error()) as InjectionError));\n error.addKey = addKey;\n error.keys = [key];\n error.injectors = [injector];\n error.constructResolvingMessage = constructResolvingMessage;\n error.message = error.constructResolvingMessage();\n ( /** @type {?} */((error as any)))[ERROR_ORIGINAL_ERROR] = originalError;\n return error;\n}\n/**\n * @this {?}\n * @param {?} injector\n * @param {?} key\n * @return {?}\n */\nfunction addKey(this: InjectionError, injector: ReflectiveInjector, key: ReflectiveKey): void {\n this.injectors.push(injector);\n this.keys.push(key);\n this.message = this.constructResolvingMessage();\n}\n/**\n * Thrown when trying to retrieve a dependency by key from {\\@link Injector}, but the\n * {\\@link Injector} does not have a {\\@link Provider} for the given key.\n * \n * ### Example ([live demo](http://plnkr.co/edit/vq8D3FRB9aGbnWJqtEPE?p=preview))\n * \n * ```typescript\n * class A {\n * constructor(b:B) {}\n * }\n * \n * expect(() => Injector.resolveAndCreate([A])).toThrowError();\n * ```\n * @param {?} injector\n * @param {?} key\n * @return {?}\n */\nexport function noProviderError(injector: ReflectiveInjector, key: ReflectiveKey): InjectionError {\n return injectionError(injector, key, function(this: InjectionError) {\n const /** @type {?} */ first = stringify(this.keys[0].token);\n return `No provider for ${first}!${constructResolvingPath(this.keys)}`;\n });\n}\n/**\n * Thrown when dependencies form a cycle.\n * \n * ### Example ([live demo](http://plnkr.co/edit/wYQdNos0Tzql3ei1EV9j?p=info))\n * \n * ```typescript\n * var injector = Injector.resolveAndCreate([\n * {provide: \"one\", useFactory: (two) => \"two\", deps: [[new Inject(\"two\")]]},\n * {provide: \"two\", useFactory: (one) => \"one\", deps: [[new Inject(\"one\")]]}\n * ]);\n * \n * expect(() => injector.get(\"one\")).toThrowError();\n * ```\n * \n * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.\n * @param {?} injector\n * @param {?} key\n * @return {?}\n */\nexport function cyclicDependencyError(\n injector: ReflectiveInjector, key: ReflectiveKey): InjectionError {\n return injectionError(injector, key, function(this: InjectionError) {\n return `Cannot instantiate cyclic dependency!${constructResolvingPath(this.keys)}`;\n });\n}\n/**\n * Thrown when a constructing type returns with an Error.\n * \n * The `InstantiationError` class contains the original error plus the dependency graph which caused\n * this object to be instantiated.\n * \n * ### Example ([live demo](http://plnkr.co/edit/7aWYdcqTQsP0eNqEdUAf?p=preview))\n * \n * ```typescript\n * class A {\n * constructor() {\n * throw new Error('message');\n * }\n * }\n * \n * var injector = Injector.resolveAndCreate([A]);\n * try {\n * injector.get(A);\n * } catch (e) {\n * expect(e instanceof InstantiationError).toBe(true);\n * expect(e.originalException.message).toEqual(\"message\");\n * expect(e.originalStack).toBeDefined();\n * }\n * ```\n * @param {?} injector\n * @param {?} originalException\n * @param {?} originalStack\n * @param {?} key\n * @return {?}\n */\nexport function instantiationError(\n injector: ReflectiveInjector, originalException: any, originalStack: any,\n key: ReflectiveKey): InjectionError {\n return injectionError(injector, key, function(this: InjectionError) {\n const /** @type {?} */ first = stringify(this.keys[0].token);\n return `${getOriginalError(this).message}: Error during instantiation of ${first}!${constructResolvingPath(this.keys)}.`;\n }, originalException);\n}\n/**\n * Thrown when an object other then {\\@link Provider} (or `Type`) is passed to {\\@link Injector}\n * creation.\n * \n * ### Example ([live demo](http://plnkr.co/edit/YatCFbPAMCL0JSSQ4mvH?p=preview))\n * \n * ```typescript\n * expect(() => Injector.resolveAndCreate([\"not a type\"])).toThrowError();\n * ```\n * @param {?} provider\n * @return {?}\n */\nexport function invalidProviderError(provider: any) {\n return Error(\n `Invalid provider - only instances of Provider and Type are allowed, got: ${provider}`);\n}\n/**\n * Thrown when the class has no annotation information.\n * \n * Lack of annotation information prevents the {\\@link Injector} from determining which dependencies\n * need to be injected into the constructor.\n * \n * ### Example ([live demo](http://plnkr.co/edit/rHnZtlNS7vJOPQ6pcVkm?p=preview))\n * \n * ```typescript\n * class A {\n * constructor(b) {}\n * }\n * \n * expect(() => Injector.resolveAndCreate([A])).toThrowError();\n * ```\n * \n * This error is also thrown when the class not marked with {\\@link Injectable} has parameter types.\n * \n * ```typescript\n * class B {}\n * \n * class A {\n * constructor(b:B) {} // no information about the parameter types of A is available at runtime.\n * }\n * \n * expect(() => Injector.resolveAndCreate([A,B])).toThrowError();\n * ```\n * \\@stable\n * @param {?} typeOrFunc\n * @param {?} params\n * @return {?}\n */\nexport function noAnnotationError(typeOrFunc: Type<any>| Function, params: any[][]): Error {\n const /** @type {?} */ signature: string[] = [];\n for (let /** @type {?} */ i = 0, /** @type {?} */ ii = params.length; i < ii; i++) {\n const /** @type {?} */ parameter = params[i];\n if (!parameter || parameter.length == 0) {\n signature.push('?');\n } else {\n signature.push(parameter.map(stringify).join(' '));\n }\n }\n return Error(\n 'Cannot resolve all parameters for \\'' + stringify(typeOrFunc) + '\\'(' +\n signature.join(', ') + '). ' +\n 'Make sure that all the parameters are decorated with Inject or have valid type annotations and that \\'' +\n stringify(typeOrFunc) + '\\' is decorated with Injectable.');\n}\n/**\n * Thrown when getting an object by index.\n * \n * ### Example ([live demo](http://plnkr.co/edit/bRs0SX2OTQiJzqvjgl8P?p=preview))\n * \n * ```typescript\n * class A {}\n * \n * var injector = Injector.resolveAndCreate([A]);\n * \n * expect(() => injector.getAt(100)).toThrowError();\n * ```\n * \\@stable\n * @param {?} index\n * @return {?}\n */\nexport function outOfBoundsError(index: number) {\n return Error(`Index ${index} is out-of-bounds.`);\n}\n/**\n * Thrown when a multi provider and a regular provider are bound to the same token.\n * \n * ### Example\n * \n * ```typescript\n * expect(() => Injector.resolveAndCreate([\n * { provide: \"Strings\", useValue: \"string1\", multi: true},\n * { provide: \"Strings\", useValue: \"string2\", multi: false}\n * ])).toThrowError();\n * ```\n * @param {?} provider1\n * @param {?} provider2\n * @return {?}\n */\nexport function mixingMultiProvidersWithRegularProvidersError(\n provider1: any, provider2: any): Error {\n return Error(`Cannot mix multi providers and regular providers, got: ${provider1} ${provider2}`);\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 '../type';\nimport {stringify} from '../util';\n\nimport {InjectionToken} from './injection_token';\n\nconst /** @type {?} */ _THROW_IF_NOT_FOUND = new Object();\nexport const /** @type {?} */ THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\nclass _NullInjector implements Injector {\n/**\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\nget(token: any, notFoundValue: any = _THROW_IF_NOT_FOUND): any {\n if (notFoundValue === _THROW_IF_NOT_FOUND) {\n throw new Error(`No provider for ${stringify(token)}!`);\n }\n return notFoundValue;\n }\n}\n/**\n * \\@whatItDoes Injector interface\n * \\@howToUse \n * ```\n * const injector: Injector = ...;\n * injector.get(...);\n * ```\n * \n * \\@description \n * For more details, see the {\\@linkDocs guide/dependency-injection \"Dependency Injection Guide\"}.\n * \n * ### Example\n * \n * {\\@example core/di/ts/injector_spec.ts region='Injector'}\n * \n * `Injector` returns itself when given `Injector` as a token:\n * {\\@example core/di/ts/injector_spec.ts region='injectInjector'}\n * \n * \\@stable\n * @abstract\n */\nexport abstract class Injector {\n static THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n static NULL: Injector = new _NullInjector();\n/**\n * Retrieves an instance from the injector based on the provided token.\n * If not found:\n * - Throws an error if no `notFoundValue` that is not equal to\n * Injector.THROW_IF_NOT_FOUND is given\n * - Returns the `notFoundValue` otherwise\n * @abstract\n * @template T\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\nget<T>(token: Type<T>|InjectionToken<T>, notFoundValue?: T) {}\n/**\n * @deprecated from v4.0.0 use Type<T> or InjectionToken<T>\n * @suppress {duplicate}\n * @abstract\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\nget(token: any, notFoundValue?: any) {}\n}\n\nfunction Injector_tsickle_Closure_declarations() {\n/** @type {?} */\nInjector.THROW_IF_NOT_FOUND;\n/** @type {?} */\nInjector.NULL;\n}\n\n"],"names":["LifecycleHooks","OnInit","OnDestroy","DoCheck","OnChanges","AfterContentInit","AfterContentChecked","AfterViewInit","AfterViewChecked","initialized","DebugAction","create","detectChanges","checkNoChanges","DebugContext_","view","nodeIndex","this","nodeDef","def","nodes","elDef","elView","flags","parent","viewParentEl","Object","defineProperty","prototype","get","tokens","push","childDef","token","references","collectReferences","elData","findHostElement","elOrCompView","logError","console","values","_i","arguments","length","logViewDef","logNodeIndex","index","renderNodeIndex","getRenderNodeIndex","currRenderNodeIndex","nodeLogger","NOOP","error","DebugRendererFactory2","createRenderer","element","renderData","DebugRenderer2","debugEl","DebugElement","el","debugCtx","getCurrentDebugContext","debugChildEl","getDebugNode","oldChild","ApplicationModule","appRef","decorators","type","NgModule","args","providers","ApplicationRef_","provide","ApplicationRef","useExisting","ApplicationInitStatus","Compiler","APP_ID_RANDOM_PROVIDER","IterableDiffers","useFactory","_iterableDiffersFactory","_localeFactory","deps","Inject","LOCALE_ID","Optional","SkipSelf","_component","_viewRef","configurable","_elDef","ViewContainerRef_","len","_embeddedViews","remove","detach","ViewRef_","reattach","_view","state","onDestroy","callback","disposables","_appRef","detachView","attachToAppRef","Error","TemplateRef_","_parentView","_def","notFoundValue","Injector","THROW_IF_NOT_FOUND","delegate","createElement","name","ns","RendererAdapter","createViewRoot","hostElement","parentElement","parentNode","node","ViewContainerRef","EventListener","DebugNode","nativeNode","_debugContext","addChild","_this","classes","child","insertChildrenAfter","newChildren","siblingIndex","childNodes","indexOf","insertBefore","refChild","newChild","refIndex","removeChild","ValueUnwrapper","unwrap","value","WrappedValue","DefaultIterableDiffer","trackByFn","_length","_collection","_linkedRecords","_unlinkedRecords","_previousItHead","_itHead","_itTail","_movesTail","forEachItem","fn","forEachOperation","addRemoveOffset","nextIt","nextRemove","record","getPreviousIndex","moveOffsets","adjPreviousIndex","currentIndex","_nextRemoved","previousIndex","localMovePreviousIndex","localCurrentIndex","i","offset","forEachPreviousItem","forEachAddedItem","forEachMovedItem","forEachRemovedItem","forEachIdentityChange","diff","collection","check","_reset","item","itemTrackBy","mayBeDirty","Array","isArray","index_1","_trackByFn","looseIdentical","trackById","_verifyReinsertion","_addIdentityChange","_next","iterateListLike","isDirty","nextRecord","_nextPrevious","_additionsHead","_nextAdded","_mismatch","previousRecord","_moveAfter","_truncate","_addToRemovals","_unlink","clear","_additionsTail","_nextMoved","_reinsertAfter","prevRecord","prev","_prevRemoved","next","_removalsHead","_insertAfter","_prev","_addToMoves","toIndex","_DuplicateMap","_removalsTail","_identityChangesTail","_identityChangesHead","toString","list","previous","additions","moves","removals","identityChanges","join","_nextIdentityChange","stringify","_DuplicateItemRecordList","_head","_tail","_prevDup","_nextDup","recordList","map","key","DefaultKeyValueDifferFactory","cd","DefaultKeyValueDiffer","_records","Map","_changesHead","_changesTail","forEachChangedItem","_mapHead","_appendAfter","_forEach","_maybeAddToChanges","_getOrCreateRecordForKey","_insertBeforeOrAppend","delete","previousValue","currentValue","before","has","record_1","KeyValueChangeRecord_","_previousMapHead","_nextChanged","newValue","items","changes","r","obj","forEach","factories","find","iterable","KeyValueDiffers","TRANSLATIONS","InjectionToken","TRANSLATIONS_FORMAT","MissingTranslationStrategy","Warning","Ignore","SecurityContext","NONE","HTML","DebugContext","injector","component","providerTokens","context","Services","setCurrentNode","createRootView","createEmbeddedView","checkNoChangesView","_tokenKeyCache","EMPTY_RENDERER_TYPE_ID","_renderCompCount","VIEW_DEFINITION_CACHE","WeakMap","NS_PREFIX_RE","ComponentFactory_","selector","componentType","viewDefFactory","_inputs","_outputs","ngContentSelectors","inputs","propName","inputsArr","projectableNodes","rootSelectorOrNode","ngModule","viewDef","resolveViewDefinition","ComponentRef_","slotCount","encapsulation","RenderDebugInfo","_dirty","QueryList","notifyOnChanges","_emitter","emit","SystemJsNgModuleLoaderConfig","SystemJsNgModuleLoader","loadAndCompile","path","loadFactory","factoryClassSuffix","FACTORY_CLASS_SUFFIX","undefined","exportName","System","import","_config","factoryPathPrefix","module","factoryPathSuffix","then","factory","checkNotEmpty","ModuleWithComponentFactories","ngModuleFactory","componentFactories","clearCacheFor","trace","events","_factories","_parent","resolveComponentFactory","ComponentFactoryBoundToModule","_ngModule","NgModuleRef","NgModuleFactory","parentInjector","instance","_injectorClass","NULL","_cmpFactoryResolver","CodegenComponentFactoryResolver","ComponentFactoryResolver","NgModuleInjector","constructor","EventEmitter","isAsync","subscribe","generatorOrNext","complete","schedulerFn","errorFn","err","completeFn","__isAsync","setTimeout","NgZone","_a","_b","enableLongStackTrace","_hasPendingMicrotasks","_hasPendingMacrotasks","_isStable","_nesting","_onUnstable","_onMicrotaskEmpty","_onStable","_onErrorEvents","Zone","inner","fork","forkInnerZoneWithAngularBehavior","checkStable","properties","isAngularZone","onInvokeTask","current","target","task","applyThis","applyArgs","onEnter","invokeTask","onLeave","onInvoke","source","onHasTask","hasTaskState","hasTask","change","setHasMicrotask","microTask","setHasMacrotask","macroTask","onHandleError","handleError","Testability","_watchAngularEvents","_ngZone","onUnstable","_didWork","_isZoneStable","runOutsideAngular","onStable","_runCallbacksIfReady","_pendingCount","scheduleMicroTask","_callbacks","findProviders","using","provider","exactMatch","TestabilityRegistry","findTestabilityInTree","elem","findInAncestors","_testabilityGetter","NgProbeToken","PlatformRef_","_super","_injector","__extends","ngZone","isDevMode","run","ngZoneInjector","ReflectiveInjector","resolveAndCreate","useValue","moduleRef","moduleFactory","exceptionHandler","ErrorHandler","_modules","compilerOptions","_moduleDoBootstrap","bootstrapFactories","f","bootstrap","ngDoBootstrap","_zone","_console","_exceptionHandler","_componentFactoryResolver","_initStatus","call","_bootstrapListeners","_rootComponents","_rootComponentTypes","_views","_runningTick","_enforceNoNewChanges","_stable","onMicrotaskEmpty","tick","isCurrentlyStable","rxjs_Observable","Observable","observer","isStable","stableSub","assertNotInAngularZone","hasPendingMacrotasks","hasPendingMicrotasks","unstableSub","assertInAngularZone","unsubscribe","componentOrFactory","done","componentFactory","ComponentFactory","compRef","_unloadComponent","testability","_loadComponent","componentRef","scope","_tickScope","e","Injectable","Console","warn","message","deprecatedParameter","originalError","_findOriginalError","_findContext","_globalKeyRegistry","numberOfKeys","_allKeys","result","paramTypes","paramAnnotations","parameters","parentCtor","tsickleCtorParams","ctorParameters","ctorParam","convertTsickleDecoratorIntoMetadata","_reflect","getOwnMetadata","ReflectionCapabilities","_ownAnnotations","typeOrFunc","annotations","propMetadata","propDecorators","propDecorators_1","propMetadata_1","isType","getParentCtor","parentPropMetadata_1","keys","ownPropMetadata","_ownPropMetadata","Reflector","updateCapabilities","caps","reflectionCapabilities","getter","setter","method","ResolvedReflectiveFactory","dependencies","ReflectiveInjector_","_providers","_constructionCounter","_instantiateProvider","_getMaxNumberOfObjects","objs","multiProvider","_instantiate","ResolvedReflectiveFactory$$1","dep","_getByReflectiveDependency","addKey","_getByKey","visibility","_getByKeySelf","_getObjByKeyId","keyId","_getByKeyDefault","inj","inj_","id","UNDEFINED","appInits","_done","asyncInitPromises","initResult","_donePromise","Component","makeDecorator","outputs","host","exportAs","moduleId","viewProviders","changeDetection","ChangeDetectionStrategy","Default","declarations","imports","exports","entryComponents","ViewMetadata","templateUrl","Version","full","split","slice","OpaqueToken","__window","window","_global","__global","__self","_symbolIterator","Reflect","ViewChild","makePropDecorator","first","isViewQuery","descendants","read","Query","OnPush","ChangeDetectorStatus","CheckOnce","Checked","Destroyed","updateDirectives","updateRenderer","viewBindingCount","viewDisposableCount","viewNodeFlags","viewRootNodeFlags","viewMatchedQueries","currentParent","currentElementHasPublicProviders","currentElementHasPrivateProviders","lastRenderRootNode","childCount","newParent","childMatchedQueries","bindingIndex","outputIndex","currentRenderParent","renderParent","publicProviders","allProviders","validateNode","matchedQueryIds","template","nodeMatchedQueries","childFlags","directChildFlags","bindings","isPrivateService","isComponent","tokenKey","componentProvider","handleEvent","eventName","event","nodeFlags","nodeCount","parentFlags","query","createView","root","renderer","parentNodeDef","outputCount","createViewNodes","renderHost","isComponentView","hostDef","asElementData","renderElement","nodeData","componentView","compViewDef","rendererType","componentRendererType","compRenderer","rendererFactory","listenToElementOutputs","viewContainer","createTemplateData","createViewContainerData","createText","createProviderInstance","createPipeInstance","createDirectiveInstance","compView","initView","createPureExpression","execEmbeddedViewsAction","ViewAction","CheckNoChanges","checkAndUpdateView","CheckAndUpdate","execQueriesAction","callLifecycleHooksChildrenFirst","checkAndUpdateNodeInline","v0","v1","v2","v3","v4","v5","v6","v7","v8","v9","changed","checkAndUpdateElementInline","checkAndUpdateTextInline","checkAndUpdateDirectiveInline","checkAndUpdateNodeDynamic","checkAndUpdateElementDynamic","checkAndUpdateTextDynamic","checkNoChangesNodeInline","bindLen","checkBindingNoChanges","checkNoChangesQuery","destroyView","Destroy","execComponentViewsAction","destroyViewNodes","asTextData","renderText","action","embeddedViews","callViewAction","viewState","queryFlags","staticDynamicQueryFlag","checkType","checkAndUpdateQuery","initServicesIfNeeded","services","createDebugServices","createProdServices","resolveDep","createDebugContext","dirtyParentQueries","createProdRootView","prodCheckAndUpdateNode","debugSetCurrentNode","debugCreateRootView","debugDestroyView","callWithDebugContext","destroy","debugCheckDirectivesFn","argStyle","debugCheckAndUpdateNode","debugCheckRenderNodeFn","givenValues","apply","concat","bindingValues","binding","normalizeDebugBindingName","attr","setValue","JSON","self","oldAction","_currentAction","oldView","_currentView","oldNodeIndex","_currentNodeIndex","isViewDebugError","textDef","ngContentIndex","constants","nonMinifiedName","securityContext","matchedQueries","checkAndUpdateBinding","prefix","_addInterpolationPart","queryDef","bindingDefs","bindingType","queryIds","isEmbeddedView","tplDef","end","filterId","queryList","asQueryList","dirty","directiveInstance","newValues","elementDef_1","calcQueryValues","asProviderData","reset","notify","boundValue","startIndex","endIndex","valueType","elementData","k","embeddedView","dvc","declaredViewContainer","projectedViews","_projectedViews","projectedView","getQueryValue","queryValueType","ElementRef","_pureExpressionDef","propertyNames","prop","checkAndUpdatePureExpressionInline","data","asPureExpressionData","pipe","transform","attachEmbeddedView","parentView","viewIndex","viewContainerParent","addToArray","dvcElementData","detachEmbeddedView","moveEmbeddedView","oldViewIndex","newViewIndex","prevRenderNode","removeFromArray","arr","nodeValue","directiveDef","ctor","props","suffix","matchedQueriesDsl","splitMatchedQueriesDsl","depDefs","allowPrivateServices","eventHandlerClosure","providerData","directive","checkBinding","updateProp","checkAndUpdateDirectiveDynamic","_createProviderInstance","injectable","providerDef","createClass","callFactory","depDef","startView","tokenKey$$1","ChangeDetectorRefTokenKey","RendererV1TokenKey","findCompView","createRendererV1","Renderer2TokenKey","ElementRefTokenKey","ViewContainerRefTokenKey","TemplateRefTokenKey","cdView","createChangeDetectorRef","InjectorRefTokenKey","createInjector","providerDef_1","NOT_CREATED","bindingIdx","oldValue","oldValues","lifecycles","callProviderLifecycles","ngAfterContentInit","ngAfterContentChecked","ngAfterViewInit","ngContentDef","appendNgContent","templateFactory","bindingFlags","attrs","elementDef","namespaceAndName","fixedAttrs","splitNamespace","_c","namespaceAndName_1","suffixOrSecurityContext","_d","ns_1","name_1","outputDefs","_e","resolveRendererType2","calcBindingFlags","selectorOrNode","createComment","parentEl","getParentRenderElement","appendChild","output","handleEventClosure","renderEventHandlerClosure","elementEventFullName","checkAndUpdateElementValue","renderNode$$1","setElementAttribute","setElementClass","setElementStyle","renderValue","sanitizer","sanitize","STYLE","unit","unwrapValue","nodeIdx","wrapped","globalBindingIdx","styles","UNDEFINED_RENDERER_TYPE_ID","isFilled","ViewEncapsulation","None","dispatchEvent","queryId","Native","visitProjectedRenderNodes","nextSibling","hostView","hostElDef","visitRenderNode","rn","renderNode","execRenderNodeAction","inlineInterpolate","valueCount","c0","a1","c1","a2","c2","a3","c3","a4","c4","a5","c5","a6","c6","a7","c7","a8","c8","a9","c9","_toStringWithNull","_reflector","reflector","devModeEqual","a","b","isListLikeIterableA","isListLikeIterable","isListLikeIterableB","areIterablesEqual","comparator","iterator1","getSymbolIterator","iterator2","noComponentFactoryError","detectWTF","createPlatform","createPlatformFactory","parentPlatformFactory","marker","extraProviders","platform","getPlatform","ALLOW_MULTIPLE_PLATFORMS","_callAndReportToErrorHandler","errorHandler","isPromise","registerModuleFactory","_queryNodeChildren","predicate","matches","findFirstClosedCycle","res","noAnnotationError","params","signature","ii","parameter","decoratorInvocations","decoratorType","decoratorInvocation","resolveReflectiveFactory","factoryFn","resolvedDeps","useClass","resolveForwardRef","_dependenciesFor","aliasInstance","ReflectiveDependency","fromKey","ReflectiveKey","mergeResolvedReflectiveProviders","normalizedProvidersMap","existing","mixingMultiProvidersWithRegularProvidersError","j","resolvedFactories","set","resolvedProvider","_normalizeProviders","Type","_extractToken","metadata","optional","_createDependency","paramMetadata","Self","Symbol","iterator","getOwnPropertyNames","overriddenName","applyParams","fnOrArray","String","Function","Number","annoLength","paramsAnnotations","annotation","extractAnnotation","Class","clsDef","hasOwnProperty","proto","extends","DecoratorFactory","objOrType","metaCtor","annotationInstance","chainAnnotation","TypeDecorator","cls","defineMetadata","chainFn","makeMetadataCtor","parentClass","argVal","ParamDecoratorFactory","ParamDecorator","unusedKey","PropDecoratorFactory","decoratorInstance","bind","meta","unshift"],"mappings":"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"} |