@angular/core/bundles/core.umd.min.js.map

{"version":3,"file":"core.umd.min.js","sources":["../../../../packages/core/src/view/services.ts","../../../../packages/core/src/view/entrypoint.ts","../../../../packages/core/src/view/refs.ts","../../../../packages/core/src/view/view.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/application_module.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/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/view.ts","../../../../packages/core/src/metadata.ts","../../../../packages/core/src/version.ts","../../../../node_modules/tslib/tslib.es6.js","../../../../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/metadata/directives.ts","../../../../packages/core/src/view/text.ts","../../../../packages/core/src/view/pure_expression.ts","../../../../packages/core/src/view/ng_content.ts","../../../../packages/core/src/view/query.ts","../../../../packages/core/src/view/view_attach.ts","../../../../packages/core/src/view/provider.ts","../../../../packages/core/src/view/element.ts","../../../../packages/core/src/view/ng_module.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 {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';\nimport {Type} from '../type';\n\nimport {isViewDebugError, viewDestroyedError, viewWrappedDebugError} from './errors';\nimport {resolveDep} from './provider';\nimport {dirtyParentQueries, getQueryValue} from './query';\nimport {createInjector, createNgModuleRef} from './refs';\nimport {ArgumentType, BindingFlags, CheckType, DebugContext, DepDef, ElementData, NgModuleDefinition, NgModuleProviderDef, NodeDef, NodeFlags, NodeLogger, ProviderOverride, RootData, Services, ViewData, ViewDefinition, ViewState, asElementData, asPureExpressionData} from './types';\nimport {NOOP, isComponentView, renderNode, splitDepsDsl, viewParentEl} from './util';\nimport {checkAndUpdateNode, checkAndUpdateView, checkNoChangesNode, checkNoChangesView, createComponentView, 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.createComponentView = services.createComponentView;\n  Services.createNgModuleRef = services.createNgModuleRef;\n  Services.overrideProvider = services.overrideProvider;\n  Services.clearProviderOverrides = services.clearProviderOverrides;\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    createComponentView: createComponentView,\n    createNgModuleRef: createNgModuleRef,\n    overrideProvider: NOOP,\n    clearProviderOverrides: NOOP,\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    createComponentView: debugCreateComponentView,\n    createNgModuleRef: debugCreateNgModuleRef,\n    overrideProvider: debugOverrideProvider,\n    clearProviderOverrides: debugClearProviderOverrides,\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  const /** @type {?} */ defWithOverride = applyProviderOverridesToView(def);\n  return callWithDebugContext(\n      DebugAction.create, createRootView, null, [root, defWithOverride, 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 {?} parentView\n * @param {?} anchorDef\n * @param {?} viewDef\n * @param {?=} context\n * @return {?}\n */\nfunction debugCreateEmbeddedView(\n    parentView: ViewData, anchorDef: NodeDef, viewDef: ViewDefinition, context?: any): ViewData {\n  const /** @type {?} */ defWithOverride = applyProviderOverridesToView(viewDef);\n  return callWithDebugContext(\n      DebugAction.create, createEmbeddedView, null,\n      [parentView, anchorDef, defWithOverride, context]);\n}\n/**\n * @param {?} parentView\n * @param {?} nodeDef\n * @param {?} viewDef\n * @param {?} hostElement\n * @return {?}\n */\nfunction debugCreateComponentView(\n    parentView: ViewData, nodeDef: NodeDef, viewDef: ViewDefinition, hostElement: any): ViewData {\n  const /** @type {?} */ defWithOverride = applyProviderOverridesToView(viewDef);\n  return callWithDebugContext(\n      DebugAction.create, createComponentView, null,\n      [parentView, nodeDef, defWithOverride, hostElement]);\n}\n/**\n * @param {?} moduleType\n * @param {?} parentInjector\n * @param {?} bootstrapComponents\n * @param {?} def\n * @return {?}\n */\nfunction debugCreateNgModuleRef(\n    moduleType: Type<any>, parentInjector: Injector, bootstrapComponents: Type<any>[],\n    def: NgModuleDefinition): NgModuleRef<any> {\n  const /** @type {?} */ defWithOverride = applyProviderOverridesToNgModule(def);\n  return createNgModuleRef(moduleType, parentInjector, bootstrapComponents, defWithOverride);\n}\n\nconst /** @type {?} */ providerOverrides = new Map<any, ProviderOverride>();\n/**\n * @param {?} override\n * @return {?}\n */\nfunction debugOverrideProvider(override: ProviderOverride) {\n  providerOverrides.set(override.token, override);\n}\n/**\n * @return {?}\n */\nfunction debugClearProviderOverrides() {\n  providerOverrides.clear();\n}\n/**\n * @param {?} def\n * @return {?}\n */\nfunction applyProviderOverridesToView(def: ViewDefinition): ViewDefinition {\n  if (providerOverrides.size === 0) {\n    return def;\n  }\n  const /** @type {?} */ elementIndicesWithOverwrittenProviders = findElementIndicesWithOverwrittenProviders(def);\n  if (elementIndicesWithOverwrittenProviders.length === 0) {\n    return def;\n  }\n  // clone the whole view definition,\n  // as it maintains references between the nodes that are hard to update.\n  def = /** @type {?} */(( def.factory))(() => NOOP);\n  for (let /** @type {?} */ i = 0; i < elementIndicesWithOverwrittenProviders.length; i++) {\n    applyProviderOverridesToElement(def, elementIndicesWithOverwrittenProviders[i]);\n  }\n  return def;\n/**\n * @param {?} def\n * @return {?}\n */\nfunction findElementIndicesWithOverwrittenProviders(def: ViewDefinition): number[] {\n    const /** @type {?} */ elIndicesWithOverwrittenProviders: number[] = [];\n    let /** @type {?} */ lastElementDef: NodeDef|null = null;\n    for (let /** @type {?} */ i = 0; i < def.nodes.length; i++) {\n      const /** @type {?} */ nodeDef = def.nodes[i];\n      if (nodeDef.flags & NodeFlags.TypeElement) {\n        lastElementDef = nodeDef;\n      }\n      if (lastElementDef && nodeDef.flags & NodeFlags.CatProviderNoDirective &&\n          providerOverrides.has( /** @type {?} */((nodeDef.provider)).token)) {\n        elIndicesWithOverwrittenProviders.push( /** @type {?} */((lastElementDef)).index);\n        lastElementDef = null;\n      }\n    }\n    return elIndicesWithOverwrittenProviders;\n  }\n/**\n * @param {?} viewDef\n * @param {?} elIndex\n * @return {?}\n */\nfunction applyProviderOverridesToElement(viewDef: ViewDefinition, elIndex: number) {\n    for (let /** @type {?} */ i = elIndex + 1; i < viewDef.nodes.length; i++) {\n      const /** @type {?} */ nodeDef = viewDef.nodes[i];\n      if (nodeDef.flags & NodeFlags.TypeElement) {\n        // stop at the next element\n        return;\n      }\n      if (nodeDef.flags & NodeFlags.CatProviderNoDirective) {\n        // Make all providers lazy, so that we don't get into trouble\n        // with ordering problems of providers on the same element\n        nodeDef.flags |= NodeFlags.LazyProvider;\n        const /** @type {?} */ provider = /** @type {?} */(( nodeDef.provider));\n        const /** @type {?} */ override = providerOverrides.get(provider.token);\n        if (override) {\n          nodeDef.flags = (nodeDef.flags & ~NodeFlags.CatProviderNoDirective) | override.flags;\n          provider.deps = splitDepsDsl(override.deps);\n          provider.value = override.value;\n        }\n      }\n    }\n  }\n}\n/**\n * @param {?} def\n * @return {?}\n */\nfunction applyProviderOverridesToNgModule(def: NgModuleDefinition): NgModuleDefinition {\n  if (providerOverrides.size === 0 || !hasOverrrides(def)) {\n    return def;\n  }\n  // clone the whole view definition,\n  // as it maintains references between the nodes that are hard to update.\n  def = /** @type {?} */(( def.factory))(() => NOOP);\n  applyProviderOverrides(def);\n  return def;\n/**\n * @param {?} def\n * @return {?}\n */\nfunction hasOverrrides(def: NgModuleDefinition): boolean {\n    return def.providers.some(\n        node =>\n            !!(node.flags & NodeFlags.CatProviderNoDirective) && providerOverrides.has(node.token));\n  }\n/**\n * @param {?} def\n * @return {?}\n */\nfunction applyProviderOverrides(def: NgModuleDefinition) {\n    for (let /** @type {?} */ i = 0; i < def.providers.length; i++) {\n      const /** @type {?} */ provider = def.providers[i];\n      // Make all providers lazy, so that we don't get into trouble\n      // with ordering problems of providers on the same element\n      provider.flags |= NodeFlags.LazyProvider;\n      const /** @type {?} */ override = providerOverrides.get(provider.token);\n      if (override) {\n        provider.flags = (provider.flags & ~NodeFlags.CatProviderNoDirective) | override.flags;\n        provider.deps = splitDepsDsl(override.deps);\n        provider.value = override.value;\n      }\n    }\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 {?} 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 * @return {?}\n */\nbegin() {\n    if (this.delegate.begin) {\n      this.delegate.begin();\n    }\n  }\n/**\n * @return {?}\n */\nend() {\n    if (this.delegate.end) {\n      this.delegate.end();\n    }\n  }\n/**\n * @return {?}\n */\nwhenRenderingDone(): Promise<any> {\n    if (this.delegate.whenRenderingDone) {\n      return this.delegate.whenRenderingDone();\n    }\n    return Promise.resolve(null);\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 {Injector} from '../di/injector';\nimport {NgModuleFactory, NgModuleRef} from '../linker/ng_module_factory';\nimport {Type} from '../type';\n\nimport {initServicesIfNeeded} from './services';\nimport {NgModuleDefinitionFactory, ProviderOverride, Services} from './types';\nimport {resolveDefinition} from './util';\n/**\n * @param {?} override\n * @return {?}\n */\nexport function overrideProvider(override: ProviderOverride) {\n  initServicesIfNeeded();\n  return Services.overrideProvider(override);\n}\n/**\n * @return {?}\n */\nexport function clearProviderOverrides() {\n  initServicesIfNeeded();\n  return Services.clearProviderOverrides();\n}\n/**\n * @param {?} ngModuleType\n * @param {?} bootstrapComponents\n * @param {?} defFactory\n * @return {?}\n */\nexport function createNgModuleFactory(\n    ngModuleType: Type<any>, bootstrapComponents: Type<any>[],\n    defFactory: NgModuleDefinitionFactory): NgModuleFactory<any> {\n  return new NgModuleFactory_(ngModuleType, bootstrapComponents, defFactory);\n}\nclass NgModuleFactory_ extends NgModuleFactory<any> {\n/**\n * @param {?} moduleType\n * @param {?} _bootstrapComponents\n * @param {?} _ngModuleDefFactory\n */\nconstructor(\npublic readonly moduleType: Type<any>,\nprivate _bootstrapComponents: Type<any>[],\nprivate _ngModuleDefFactory: NgModuleDefinitionFactory) {\n    // Attention: this ctor is called as top level function.\n    // Putting any logic in here will destroy closure tree shaking!\n    super();\n  }\n/**\n * @param {?} parentInjector\n * @return {?}\n */\ncreate(parentInjector: Injector|null): NgModuleRef<any> {\n    initServicesIfNeeded();\n    const /** @type {?} */ def = resolveDefinition(this._ngModuleDefFactory);\n    return Services.createNgModuleRef(\n        this.moduleType, parentInjector || Injector.NULL, this._bootstrapComponents, def);\n  }\n}\n\nfunction NgModuleFactory__tsickle_Closure_declarations() {\n/** @type {?} */\nNgModuleFactory_.prototype.moduleType;\n/** @type {?} */\nNgModuleFactory_.prototype._bootstrapComponents;\n/** @type {?} */\nNgModuleFactory_.prototype._ngModuleDefFactory;\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 {ApplicationRef} from '../application_ref';\nimport {ChangeDetectorRef} from '../change_detection/change_detection';\nimport {Injector} from '../di/injector';\nimport {ComponentFactory, ComponentRef} from '../linker/component_factory';\nimport {ComponentFactoryBoundToModule, ComponentFactoryResolver} from '../linker/component_factory_resolver';\nimport {ElementRef} from '../linker/element_ref';\nimport {InternalNgModuleRef, 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 {stringify} from '../util';\nimport {VERSION} from '../version';\n\nimport {callNgModuleLifecycle, initNgModule, resolveNgModuleDep} from './ng_module';\nimport {DepFlags, ElementData, NgModuleData, NgModuleDefinition, NodeDef, NodeFlags, Services, TemplateData, ViewContainerData, ViewData, ViewDefinitionFactory, ViewState, asElementData, asProviderData, asTextData} from './types';\nimport {markParentViewsForCheck, resolveDefinition, 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 = resolveDefinition(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 {\n    const /** @type {?} */ fs = this._view.root.rendererFactory;\n    if (fs.begin) {\n      fs.begin();\n    }\n    Services.checkAndUpdateView(this._view);\n    if (fs.end) {\n      fs.end();\n    }\n  }\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(\n        this._parentView, this._def, /** @type {?} */(( /** @type {?} */(( this._def.element)).template)), 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 * @param {?} moduleType\n * @param {?} parent\n * @param {?} bootstrapComponents\n * @param {?} def\n * @return {?}\n */\nexport function createNgModuleRef(\n    moduleType: Type<any>, parent: Injector, bootstrapComponents: Type<any>[],\n    def: NgModuleDefinition): NgModuleRef<any> {\n  return new NgModuleRef_(moduleType, parent, bootstrapComponents, def);\n}\nclass NgModuleRef_ implements NgModuleData, InternalNgModuleRef<any> {\nprivate _destroyListeners: (() => void)[] = [];\nprivate _destroyed: boolean = false;\npublic _providers: any[];\n/**\n * @param {?} _moduleType\n * @param {?} _parent\n * @param {?} _bootstrapComponents\n * @param {?} _def\n */\nconstructor(\nprivate _moduleType: Type<any>,\npublic _parent: Injector,\npublic _bootstrapComponents: Type<any>[],\npublic _def: NgModuleDefinition) {\n    initNgModule(this);\n  }\n/**\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\nget(token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND): any {\n    return resolveNgModuleDep(\n        this, {token: token, tokenKey: tokenKey(token), flags: DepFlags.None}, notFoundValue);\n  }\n/**\n * @return {?}\n */\nget instance() { return this.get(this._moduleType); }\n/**\n * @return {?}\n */\nget componentFactoryResolver() { return this.get(ComponentFactoryResolver); }\n/**\n * @return {?}\n */\nget injector(): Injector { return this; }\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    callNgModuleLifecycle(this, NodeFlags.OnDestroy);\n    this._destroyListeners.forEach((listener) => listener());\n  }\n/**\n * @param {?} callback\n * @return {?}\n */\nonDestroy(callback: () => void): void { this._destroyListeners.push(callback); }\n}\n\nfunction NgModuleRef__tsickle_Closure_declarations() {\n/** @type {?} */\nNgModuleRef_.prototype._destroyListeners;\n/** @type {?} */\nNgModuleRef_.prototype._destroyed;\n/** @type {?} */\nNgModuleRef_.prototype._providers;\n/** @type {?} */\nNgModuleRef_.prototype._moduleType;\n/** @type {?} */\nNgModuleRef_.prototype._parent;\n/** @type {?} */\nNgModuleRef_.prototype._bootstrapComponents;\n/** @type {?} */\nNgModuleRef_.prototype._def;\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 {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, markParentViewsForCheckProjectedViews, resolveDefinition, tokenKey} from './util';\nimport {detachProjectedView} from './view_attach';\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))[tokenKey( /** @type {?} */((node.provider)).token)] = 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))[tokenKey( /** @type {?} */((node.provider)).token)] = 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 {?} viewDef\n * @param {?=} context\n * @return {?}\n */\nexport function createEmbeddedView(\n    parent: ViewData, anchorDef: NodeDef, viewDef: ViewDefinition, 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 = createView(parent.root, parent.renderer, parent, anchorDef, viewDef);\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 {?} parentView\n * @param {?} nodeDef\n * @param {?} viewDef\n * @param {?} hostElement\n * @return {?}\n */\nexport function createComponentView(\n    parentView: ViewData, nodeDef: NodeDef, viewDef: ViewDefinition, hostElement: any): ViewData {\n  const /** @type {?} */ rendererType = /** @type {?} */(( nodeDef.element)).componentRendererType;\n  let /** @type {?} */ compRenderer: Renderer2;\n  if (!rendererType) {\n    compRenderer = parentView.root.renderer;\n  } else {\n    compRenderer = parentView.root.rendererFactory.createRenderer(hostElement, rendererType);\n  }\n  return createView(\n      parentView.root, compRenderer, parentView, /** @type {?} */(( nodeDef.element)).componentProvider, viewDef);\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 = resolveDefinition( /** @type {?} */(( /** @type {?} */((nodeDef.element)).componentView)));\n          componentView = Services.createComponentView(view, nodeDef, compViewDef, el);\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  markProjectedViewsForCheck(view);\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  view.state &= ~(ViewState.CheckProjectedViews | ViewState.CheckProjectedView);\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  markProjectedViewsForCheck(view);\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  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  view.state &= ~(ViewState.CheckProjectedViews | ViewState.CheckProjectedView);\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 * @return {?}\n */\nfunction markProjectedViewsForCheck(view: ViewData) {\n  const /** @type {?} */ def = view.def;\n  if (!(def.nodeFlags & NodeFlags.ProjectedTemplate)) {\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.ProjectedTemplate) {\n      const /** @type {?} */ projectedViews = asElementData(view, i).template._projectedViews;\n      if (projectedViews) {\n        for (let /** @type {?} */ i = 0; i < projectedViews.length; i++) {\n          const /** @type {?} */ projectedView = projectedViews[i];\n          projectedView.state |= ViewState.CheckProjectedView;\n          markParentViewsForCheckProjectedViews(projectedView, view);\n        }\n      }\n    } else if ((nodeDef.childFlags & NodeFlags.ProjectedTemplate) === 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 {?} 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  detachProjectedView(view);\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.CheckNoChangesProjectedViews = 2;\nViewAction.CheckAndUpdate = 3;\nViewAction.CheckAndUpdateProjectedViews = 4;\nViewAction.Destroy = 5;\nViewAction[ViewAction.CreateViewNodes] = \"CreateViewNodes\";\nViewAction[ViewAction.CheckNoChanges] = \"CheckNoChanges\";\nViewAction[ViewAction.CheckNoChangesProjectedViews] = \"CheckNoChangesProjectedViews\";\nViewAction[ViewAction.CheckAndUpdate] = \"CheckAndUpdate\";\nViewAction[ViewAction.CheckAndUpdateProjectedViews] = \"CheckAndUpdateProjectedViews\";\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.Destroyed) === 0) {\n        if ((viewState & ViewState.CatDetectChanges) === ViewState.CatDetectChanges) {\n          checkNoChangesView(view);\n        } else if (viewState & ViewState.CheckProjectedViews) {\n          execProjectedViewsAction(view, ViewAction.CheckNoChangesProjectedViews);\n        }\n      }\n      break;\n    case ViewAction.CheckNoChangesProjectedViews:\n      if ((viewState & ViewState.Destroyed) === 0) {\n        if (viewState & ViewState.CheckProjectedView) {\n          checkNoChangesView(view);\n        } else if (viewState & ViewState.CheckProjectedViews) {\n          execProjectedViewsAction(view, action);\n        }\n      }\n      break;\n    case ViewAction.CheckAndUpdate:\n      if ((viewState & ViewState.Destroyed) === 0) {\n        if ((viewState & ViewState.CatDetectChanges) === ViewState.CatDetectChanges) {\n          checkAndUpdateView(view);\n        } else if (viewState & ViewState.CheckProjectedViews) {\n          execProjectedViewsAction(view, ViewAction.CheckAndUpdateProjectedViews);\n        }\n      }\n      break;\n    case ViewAction.CheckAndUpdateProjectedViews:\n      if ((viewState & ViewState.Destroyed) === 0) {\n        if (viewState & ViewState.CheckProjectedView) {\n          checkAndUpdateView(view);\n        } else if (viewState & ViewState.CheckProjectedViews) {\n          execProjectedViewsAction(view, action);\n        }\n      }\n      break;\n    case ViewAction.Destroy:\n      // Note: destroyView recurses over all views,\n      // so we don't need to special case projected views here.\n      destroyView(view);\n      break;\n    case ViewAction.CreateViewNodes:\n      createViewNodes(view);\n      break;\n  }\n}\n/**\n * @param {?} view\n * @param {?} action\n * @return {?}\n */\nfunction execProjectedViewsAction(view: ViewData, action: ViewAction) {\n  execEmbeddedViewsAction(view, action);\n  execComponentViewsAction(view, action);\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 {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 < /** @type {?} */(( 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","/**\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 {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';\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 * 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  ]\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","\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';\nimport {Type} from '../type';\n\n// -------------------------------------\n// Defs\n// -------------------------------------\n\n/**\n * Factory for ViewDefinitions/NgModuleDefinitions.\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 DefinitionFactory<D extends Definition<any>> { (logger: NodeLogger): D; }\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 Definition<DF extends DefinitionFactory<any>> { factory: DF|null; }\n\nexport interface NgModuleDefinition extends Definition<NgModuleDefinitionFactory> {\n  providers: NgModuleProviderDef[];\n  providersByKey: {[tokenKey: string]: NgModuleProviderDef};\n}\n\nexport interface NgModuleDefinitionFactory extends DefinitionFactory<NgModuleDefinition> {}\n;\n\nexport interface ViewDefinition extends Definition<ViewDefinitionFactory> {\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\nexport interface ViewDefinitionFactory extends DefinitionFactory<ViewDefinition> {}\n\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  ProjectedTemplate = 1 << 2,\n  CatRenderNode = TypeElement | TypeText,\n  TypeNgContent = 1 << 3,\n  TypePipe = 1 << 4,\n  TypePureArray = 1 << 5,\n  TypePureObject = 1 << 6,\n  TypePurePipe = 1 << 7,\n  CatPureExpression = TypePureArray | TypePureObject | TypePurePipe,\n  TypeValueProvider = 1 << 8,\n  TypeClassProvider = 1 << 9,\n  TypeFactoryProvider = 1 << 10,\n  TypeUseExistingProvider = 1 << 11,\n  LazyProvider = 1 << 12,\n  PrivateProvider = 1 << 13,\n  TypeDirective = 1 << 14,\n  Component = 1 << 15,\n  CatProviderNoDirective =\n      TypeValueProvider | TypeClassProvider | TypeFactoryProvider | TypeUseExistingProvider,\n  CatProvider = CatProviderNoDirective | TypeDirective,\n  OnInit = 1 << 16,\n  OnDestroy = 1 << 17,\n  DoCheck = 1 << 18,\n  OnChanges = 1 << 19,\n  AfterContentInit = 1 << 20,\n  AfterContentChecked = 1 << 21,\n  AfterViewInit = 1 << 22,\n  AfterViewChecked = 1 << 23,\n  EmbeddedViews = 1 << 24,\n  ComponentView = 1 << 25,\n  TypeContentQuery = 1 << 26,\n  TypeViewQuery = 1 << 27,\n  StaticQuery = 1 << 28,\n  DynamicQuery = 1 << 29,\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  value: any;\n  deps: DepDef[];\n}\n\nexport interface NgModuleProviderDef {\n  flags: NodeFlags;\n  index: number;\n  token: any;\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\nexport interface NgModuleData extends Injector, NgModuleRef<any> {\n  // Note: we are using the prefix _ as NgModuleData is an NgModuleRef and therefore directly\n  // exposed to the user.\n  _def: NgModuleDefinition;\n  _parent: Injector;\n  _providers: any[];\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  IsProjectedView = 1 << 4,\n  CheckProjectedView = 1 << 5,\n  CheckProjectedViews = 1 << 6,\n  Destroyed = 1 << 7,\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 {\n  // Note: we are using the prefix _ as ViewContainerData is a ViewContainerRef and therefore\n  // directly\n  // exposed to the user.\n  _embeddedViews: ViewData[];\n}\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  // Note: we are using the prefix _ as TemplateData is a TemplateRef and therefore directly\n  // exposed to the user.\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 ProviderOverride {\n  token: any;\n  flags: NodeFlags;\n  value: any;\n  deps: ([DepFlags, any]|any)[];\n}\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, viewDef: ViewDefinition, context?: any):\n      ViewData;\n  createComponentView(\n      parentView: ViewData, nodeDef: NodeDef, viewDef: ViewDefinition, hostElement: any): ViewData;\n  createNgModuleRef(\n      moduleType: Type<any>, parent: Injector, bootstrapComponents: Type<any>[],\n      def: NgModuleDefinition): NgModuleRef<any>;\n  overrideProvider(override: ProviderOverride): void;\n  clearProviderOverrides(): void;\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 * 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 Services: Services = {\n  setCurrentNode: undefined !,\n  createRootView: undefined !,\n  createEmbeddedView: undefined !,\n  createComponentView: undefined !,\n  createNgModuleRef: undefined !,\n  overrideProvider: undefined !,\n  clearProviderOverrides: undefined !,\n  checkAndUpdateView: undefined !,\n  checkNoChangesView: undefined !,\n  destroyView: undefined !,\n  resolveDep: undefined !,\n  createDebugContext: undefined !,\n  handleEvent: undefined !,\n  updateDirectives: undefined !,\n  updateRenderer: undefined !,\n  dirtyParentQueries: 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, Definition, DefinitionFactory, DepDef, DepFlags, 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 {?} endView\n * @return {?}\n */\nexport function markParentViewsForCheckProjectedViews(view: ViewData, endView: ViewData) {\n  let /** @type {?} */ currView: ViewData|null = view;\n  while (currView && currView !== endView) {\n    currView.state |= ViewState.CheckProjectedViews;\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 {?} deps\n * @return {?}\n */\nexport function splitDepsDsl(deps: ([DepFlags, any] | any)[]): DepDef[] {\n  return 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/**\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 {?} */ DEFINITION_CACHE = new WeakMap<any, Definition<any>>();\n/**\n * @template D\n * @param {?} factory\n * @return {?}\n */\nexport function resolveDefinition<D extends Definition<any>>(factory: DefinitionFactory<D>): D {\n  let /** @type {?} */ value = /** @type {?} */(( /** @type {?} */(( DEFINITION_CACHE.get(factory)))as D));\n  if (!value) {\n    value = factory(() => NOOP);\n    value.factory = factory;\n    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 Renderer#setElementProperty} or {\\@link\n * Renderer#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/**\n * @abstract\n * @return {?}\n */\nbegin?() {}\n/**\n * @abstract\n * @return {?}\n */\nend?() {}\n/**\n * @abstract\n * @return {?}\n */\nwhenRenderingDone?() {}\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 */\ndestroyNode: ((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';\ndeclare var System: any;\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 */\nfactoryPathPrefix: string;\n/**\n * Suffix to add when computing the name of the factory module for a given module name.\n */\nfactoryPathSuffix: 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);\n    if (!factory && this._parent) {\n      factory = this._parent.resolveComponentFactory(component);\n    }\n    if (!factory) {\n      throw noComponentFactoryError(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 {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 {\\@link EventEmitter}, which depending on `isAsync`,\n * delivers events synchronously or asynchronously.\n * \n * @param {?=} isAsync By default, events are delivered synchronously (default value: `false`).\n * Set to `true` for asynchronous event delivery.\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// Import zero symbols from zone.js. This causes the zone ambient type to be\n// added to the type-checker, without emitting any runtime module load statement\n\nimport {} from 'zone.js';\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 {InternalNgModuleRef, NgModuleFactory, 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 {?} */(( <InternalNgModuleRef<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        initStatus.runInitializers();\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: InternalNgModuleRef<any>): void {\n    const /** @type {?} */ appRef = /** @type {?} */(( moduleRef.injector.get(ApplicationRef) as ApplicationRef));\n    if (moduleRef._bootstrapComponents.length > 0) {\n      moduleRef._bootstrapComponents.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 * Optionally, a component can be mounted onto a DOM element that does not match the\n * [componentType]'s selector.\n * \n * ### Example\n * {\\@example core/ts/platform/platform.ts region='longform'}\n * @abstract\n * @template C\n * @param {?} componentFactory\n * @param {?=} rootSelectorOrNode\n * @return {?}\n */\nbootstrap<C>(\n      componentFactory: ComponentFactory<C>|Type<C>,\n      rootSelectorOrNode?: string|any) {}\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 * @param {?=} rootSelectorOrNode\n * @return {?}\n */\nbootstrap<C>(componentOrFactory: ComponentFactory<C>|Type<C>, rootSelectorOrNode?: string|any):\n      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 {?} */ selectorOrNode = rootSelectorOrNode || componentFactory.selector;\n    const /** @type {?} */ compRef = componentFactory.create(Injector.NULL, [], selectorOrNode, 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 * Attention: This regex has to hold even if the code is minified!\n */\nexport const 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 {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 {\n/**\n * @param {?} reflectionCapabilities\n */\nconstructor(public reflectionCapabilities: PlatformReflectionCapabilities) {}\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[], 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 ReflectiveInjector#resolve} and {\\@link ReflectiveInjector#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 ReflectiveInjector#resolve} and {\\@link ReflectiveInjector#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 resolve: Function;\nprivate reject: Function;\nprivate initialized = false;\nprivate _donePromise: Promise<any>;\nprivate _done = false;\n/**\n * @param {?} appInits\n */\nconstructor(\nprivate appInits: (() => any)[]) {\n    this._donePromise = new Promise((res, rej) => {\n      this.resolve = res;\n      this.reject = rej;\n    });\n  }\n/**\n * \\@internal\n * @return {?}\n */\nrunInitializers() {\n    if (this.initialized) {\n      return;\n    }\n\n    const /** @type {?} */ asyncInitPromises: Promise<any>[] = [];\n\n    const /** @type {?} */ complete =\n        () => {\n          this._done = true;\n          this.resolve();\n        }\n\n    if (this.appInits) {\n      for (let /** @type {?} */ i = 0; i < this.appInits.length; i++) {\n        const /** @type {?} */ initResult = this.appInits[i]();\n        if (isPromise(initResult)) {\n          asyncInitPromises.push(initResult);\n        }\n      }\n    }\n\n    Promise.all(asyncInitPromises).then(() => { complete(); }).catch(e => { this.reject(e); });\n\n    if (asyncInitPromises.length === 0) {\n      complete();\n    }\n    this.initialized = true;\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.resolve;\n/** @type {?} */\nApplicationInitStatus.prototype.reject;\n/** @type {?} */\nApplicationInitStatus.prototype.initialized;\n/** @type {?} */\nApplicationInitStatus.prototype._donePromise;\n/** @type {?} */\nApplicationInitStatus.prototype._done;\n/** @type {?} */\nApplicationInitStatus.prototype.appInits;\n}\n\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\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/**\n * {\\@link Component#templateUrl}\n */\ntemplateUrl: string|undefined;\n/**\n * {\\@link Component#template}\n */\ntemplate: string|undefined;\n/**\n * {\\@link Component#stylesUrl}\n */\nstyleUrls: string[]|undefined;\n/**\n * {\\@link Component#styles}\n */\nstyles: string[]|undefined;\n/**\n * {\\@link Component#encapsulation}\n */\nencapsulation: ViewEncapsulation|undefined;\n/**\n * {\\@link Component#animation}\n */\nanimations: any[]|undefined;\n/**\n * {\\@link Component#interpolation}\n */\ninterpolation: [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.2.3');\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = Object.setPrototypeOf ||\r\n    ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n    function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = Object.assign || function __assign(t) {\r\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n        s = arguments[i];\r\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n    }\r\n    return t;\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [0, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);  }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { if (o[n]) i[n] = function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; }; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator];\r\n    return m ? m.call(o) : typeof __values === \"function\" ? __values(o) : o[Symbol.iterator]();\r\n}","\n/**\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// Import zero symbols from zone.js. This causes the zone ambient type to be\n// added to the type-checker, without emitting any runtime module load statement\n\nimport {} from 'zone.js';\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?: (...args: any[]) => 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?: (...args: any[]) => any): any {\n  return function ctor(...args: any[]) {\n    if (props) {\n      const /** @type {?} */ values = props(...args);\n      for (const /** @type {?} */ propName in values) {\n        this[propName] = values[propName];\n      }\n    }\n  };\n}\n/**\n * @param {?} name\n * @param {?=} props\n * @param {?=} parentClass\n * @return {?}\n */\nexport function makeParamDecorator(\n    name: string, props?: (...args: any[]) => 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?: (...args: any[]) => 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 {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 =\n    <DirectiveDecorator>makeDecorator('Directive', (dir: Directive = {}) => dir);\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', (c: Component = {}) => ({changeDetection: ChangeDetectionStrategy.Default, ...c}),\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 =\n    <PipeDecorator>makeDecorator('Pipe', (p: Pipe) => ({pure: true, ...p}));\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?: string) => ({bindingPropertyName}));\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?: string) => ({bindingPropertyName}));\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?: string) => ({hostPropertyName}));\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?: string, args?: string[]) => ({eventName, args}));\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 {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 {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 {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 {ElementData, NodeDef, NodeFlags, Services, ViewData, ViewDefinition, ViewState} from './types';\nimport {RenderNodeAction, declaredViewContainer, isComponentView, 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  attachProjectedView(elementData, view);\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 {?} vcElementData\n * @param {?} view\n * @return {?}\n */\nfunction attachProjectedView(vcElementData: ElementData, view: ViewData) {\n  const /** @type {?} */ dvcElementData = declaredViewContainer(view);\n  if (!dvcElementData || dvcElementData === vcElementData ||\n      view.state & ViewState.IsProjectedView) {\n    return;\n  }\n  // Note: For performance reasons, we\n  // - add a view to template._projectedViews only 1x throughout its lifetime,\n  //   and remove it not until the view is destroyed.\n  //   (hard, as when a parent view is attached/detached we would need to attach/detach all\n  //    nested projected views as well, even accross component boundaries).\n  // - don't track the insertion order of views in the projected views array\n  //   (hard, as when the views of the same template are inserted different view containers)\n  view.state |= ViewState.IsProjectedView;\n  let /** @type {?} */ projectedViews = dvcElementData.template._projectedViews;\n  if (!projectedViews) {\n    projectedViews = dvcElementData.template._projectedViews = [];\n  }\n  projectedViews.push(view);\n  // Note: we are changing the NodeDef here as we cannot calculate\n  // the fact whether a template is used for projection during compilation.\n  markNodeAsProjectedTemplate( /** @type {?} */((view.parent)).def, /** @type {?} */(( view.parentNodeDef)));\n}\n/**\n * @param {?} viewDef\n * @param {?} nodeDef\n * @return {?}\n */\nfunction markNodeAsProjectedTemplate(viewDef: ViewDefinition, nodeDef: NodeDef) {\n  if (nodeDef.flags & NodeFlags.ProjectedTemplate) {\n    return;\n  }\n  viewDef.nodeFlags |= NodeFlags.ProjectedTemplate;\n  nodeDef.flags |= NodeFlags.ProjectedTemplate;\n  let /** @type {?} */ parentNodeDef = nodeDef.parent;\n  while (parentNodeDef) {\n    parentNodeDef.childFlags |= NodeFlags.ProjectedTemplate;\n    parentNodeDef = parentNodeDef.parent;\n  }\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  // See attachProjectedView for why we don't update projectedViews here.\n  Services.dirtyParentQueries(view);\n\n  renderDetachView(view);\n\n  return view;\n}\n/**\n * @param {?} view\n * @return {?}\n */\nexport function detachProjectedView(view: ViewData) {\n  if (!(view.state & ViewState.IsProjectedView)) {\n    return;\n  }\n  const /** @type {?} */ dvcElementData = declaredViewContainer(view);\n  if (dvcElementData) {\n    const /** @type {?} */ projectedViews = dvcElementData.template._projectedViews;\n    if (projectedViews) {\n      removeFromArray(projectedViews, projectedViews.indexOf(view));\n      Services.dirtyParentQueries(view);\n    }\n  }\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, splitDepsDsl, 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 = splitDepsDsl(deps);\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, 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 {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, resolveDefinition, resolveRendererType2, 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 ? resolveDefinition(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 {Injector, THROW_IF_NOT_FOUND} from '../di/injector';\nimport {NgModuleRef} from '../linker/ng_module_factory';\n\nimport {DepDef, DepFlags, NgModuleData, NgModuleDefinition, NgModuleDefinitionFactory, NgModuleProviderDef, NodeFlags} from './types';\nimport {splitDepsDsl, tokenKey} from './util';\n\nconst /** @type {?} */ NOT_CREATED = new Object();\n\nconst /** @type {?} */ InjectorRefTokenKey = tokenKey(Injector);\nconst /** @type {?} */ NgModuleRefTokenKey = tokenKey(NgModuleRef);\n/**\n * @param {?} flags\n * @param {?} token\n * @param {?} value\n * @param {?} deps\n * @return {?}\n */\nexport function moduleProvideDef(\n    flags: NodeFlags, token: any, value: any,\n    deps: ([DepFlags, any] | any)[]): NgModuleProviderDef {\n  const /** @type {?} */ depDefs = splitDepsDsl(deps);\n  return {\n    // will bet set by the module definition\n    index: -1,\n    deps: depDefs, flags, token, value\n  };\n}\n/**\n * @param {?} providers\n * @return {?}\n */\nexport function moduleDef(providers: NgModuleProviderDef[]): NgModuleDefinition {\n  const /** @type {?} */ providersByKey: {[key: string]: NgModuleProviderDef} = {};\n  for (let /** @type {?} */ i = 0; i < providers.length; i++) {\n    const /** @type {?} */ provider = providers[i];\n    provider.index = i;\n    providersByKey[tokenKey(provider.token)] = provider;\n  }\n  return {\n    // Will be filled later...\n    factory: null,\n    providersByKey,\n    providers\n  };\n}\n/**\n * @param {?} data\n * @return {?}\n */\nexport function initNgModule(data: NgModuleData) {\n  const /** @type {?} */ def = data._def;\n  const /** @type {?} */ providers = data._providers = new Array(def.providers.length);\n  for (let /** @type {?} */ i = 0; i < def.providers.length; i++) {\n    const /** @type {?} */ provDef = def.providers[i];\n    providers[i] = provDef.flags & NodeFlags.LazyProvider ? NOT_CREATED :\n                                                            _createProviderInstance(data, provDef);\n  }\n}\n/**\n * @param {?} data\n * @param {?} depDef\n * @param {?=} notFoundValue\n * @return {?}\n */\nexport function resolveNgModuleDep(\n    data: NgModuleData, depDef: DepDef, notFoundValue: any = Injector.THROW_IF_NOT_FOUND): any {\n  if (depDef.flags & DepFlags.Value) {\n    return depDef.token;\n  }\n  if (depDef.flags & DepFlags.Optional) {\n    notFoundValue = null;\n  }\n  if (depDef.flags & DepFlags.SkipSelf) {\n    return data._parent.get(depDef.token, notFoundValue);\n  }\n  const /** @type {?} */ tokenKey = depDef.tokenKey;\n  switch (tokenKey) {\n    case InjectorRefTokenKey:\n    case NgModuleRefTokenKey:\n      return data;\n  }\n  const /** @type {?} */ providerDef = data._def.providersByKey[tokenKey];\n  if (providerDef) {\n    let /** @type {?} */ providerInstance = data._providers[providerDef.index];\n    if (providerInstance === NOT_CREATED) {\n      providerInstance = data._providers[providerDef.index] =\n          _createProviderInstance(data, providerDef);\n    }\n    return providerInstance;\n  }\n  return data._parent.get(depDef.token, notFoundValue);\n}\n/**\n * @param {?} ngModule\n * @param {?} providerDef\n * @return {?}\n */\nfunction _createProviderInstance(ngModule: NgModuleData, providerDef: NgModuleProviderDef): any {\n  let /** @type {?} */ injectable: any;\n  switch (providerDef.flags & NodeFlags.Types) {\n    case NodeFlags.TypeClassProvider:\n      injectable = _createClass(ngModule, providerDef.value, providerDef.deps);\n      break;\n    case NodeFlags.TypeFactoryProvider:\n      injectable = _callFactory(ngModule, providerDef.value, providerDef.deps);\n      break;\n    case NodeFlags.TypeUseExistingProvider:\n      injectable = resolveNgModuleDep(ngModule, providerDef.deps[0]);\n      break;\n    case NodeFlags.TypeValueProvider:\n      injectable = providerDef.value;\n      break;\n  }\n  return injectable;\n}\n/**\n * @param {?} ngModule\n * @param {?} ctor\n * @param {?} deps\n * @return {?}\n */\nfunction _createClass(ngModule: NgModuleData, 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(resolveNgModuleDep(ngModule, deps[0]));\n      break;\n    case 2:\n      injectable =\n          new ctor(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]));\n      break;\n    case 3:\n      injectable = new ctor(\n          resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]),\n          resolveNgModuleDep(ngModule, 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] = resolveNgModuleDep(ngModule, deps[i]);\n      }\n      injectable = new ctor(...depValues);\n  }\n  return injectable;\n}\n/**\n * @param {?} ngModule\n * @param {?} factory\n * @param {?} deps\n * @return {?}\n */\nfunction _callFactory(ngModule: NgModuleData, factory: any, 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(resolveNgModuleDep(ngModule, deps[0]));\n      break;\n    case 2:\n      injectable =\n          factory(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]));\n      break;\n    case 3:\n      injectable = factory(\n          resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]),\n          resolveNgModuleDep(ngModule, deps[2]));\n      break;\n    default:\n      const /** @type {?} */ depValues = Array(len);\n      for (let /** @type {?} */ i = 0; i < len; i++) {\n        depValues[i] = resolveNgModuleDep(ngModule, deps[i]);\n      }\n      injectable = factory(...depValues);\n  }\n  return injectable;\n}\n/**\n * @param {?} ngModule\n * @param {?} lifecycles\n * @return {?}\n */\nexport function callNgModuleLifecycle(ngModule: NgModuleData, lifecycles: NodeFlags) {\n  const /** @type {?} */ def = ngModule._def;\n  for (let /** @type {?} */ i = 0; i < def.providers.length; i++) {\n    const /** @type {?} */ provDef = def.providers[i];\n    if (provDef.flags & NodeFlags.OnDestroy) {\n      const /** @type {?} */ instance = ngModule._providers[i];\n      if (instance && instance !== NOT_CREATED) {\n        instance.ngOnDestroy();\n      }\n    }\n  }\n}\n","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n\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 {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  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: (keys: ReflectiveKey[]) => 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: (keys: ReflectiveKey[]) => string,\n    originalError?: Error): InjectionError {\n  const /** @type {?} */ keys = [key];\n  const /** @type {?} */ errMsg = constructResolvingMessage(keys);\n  const /** @type {?} */ error = /** @type {?} */((\n      (originalError ? wrappedError(errMsg, originalError) : Error(errMsg)) as InjectionError));\n  error.addKey = addKey;\n  error.keys = keys;\n  error.injectors = [injector];\n  error.constructResolvingMessage = 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  // Note: This updated message won't be reflected in the `.stack` property\n  this.message = this.constructResolvingMessage(this.keys);\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(keys: ReflectiveKey[]) {\n    const /** @type {?} */ first = stringify(keys[0].token);\n    return `No provider for ${first}!${constructResolvingPath(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(keys: ReflectiveKey[]) {\n    return `Cannot instantiate cyclic dependency!${constructResolvingPath(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(keys: ReflectiveKey[]) {\n    const /** @type {?} */ first = stringify(keys[0].token);\n    return `${originalException.message}: Error during instantiation of ${first}!${constructResolvingPath(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":["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","delegate","whenRenderingDone","DebugRenderer2","debugEl","DebugElement","el","debugCtx","getCurrentDebugContext","debugChildEl","getDebugNode","oldChild","_super","call","ComponentRef_","_view","_viewRef","_component","_this","configurable","_elDef","ViewContainerRef_","len","_embeddedViews","remove","detach","ViewRef_","state","fs","begin","reattach","onDestroy","callback","disposables","_appRef","detachView","attachToAppRef","appRef","Error","TemplateRef_","_parentView","_def","notFoundValue","Injector","THROW_IF_NOT_FOUND","createElement","name","ns","RendererAdapter","createViewRoot","hostElement","parentElement","parentNode","node","stringify","instance","constructor","ViewAction","CreateViewNodes","CheckNoChanges","ViewContainerRef","element","EventListener","DebugNode","nativeNode","_debugContext","addChild","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","_additionsTail","_movesHead","_mismatch","previousRecord","_moveAfter","_truncate","_addToRemovals","_unlink","clear","_nextMoved","_reinsertAfter","prevRecord","prev","_prevRemoved","next","_removalsHead","_insertAfter","_prev","_addToMoves","toIndex","_DuplicateMap","_removalsTail","_identityChangesTail","_identityChangesHead","toString","list","previous","additions","moves","removals","identityChanges","join","_nextIdentityChange","_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","useFactory","IterableDiffers","factories","find","iterable","provide","KeyValueDiffers","TRANSLATIONS","InjectionToken","ApplicationModule","decorators","type","NgModule","args","providers","ApplicationRef_","ApplicationRef","useExisting","ApplicationInitStatus","Compiler","APP_ID_RANDOM_PROVIDER","LOCALE_ID","_localeFactory","ctorParameters","SecurityContext","NONE","HTML","DebugContext","injector","component","providerTokens","context","Services","setCurrentNode","undefined","createRootView","createEmbeddedView","createComponentView","createNgModuleRef","overrideProvider","clearProviderOverrides","checkNoChangesView","_tokenKeyCache","EMPTY_RENDERER_TYPE_ID","_renderCompCount","NS_PREFIX_RE","ComponentFactory_","selector","componentType","viewDefFactory","_inputs","_outputs","ngContentSelectors","inputs","propName","inputsArr","projectableNodes","rootSelectorOrNode","ngModule","viewDef","resolveDefinition","slotCount","encapsulation","RenderDebugInfo","RendererFactory2","createRenderer","end","_dirty","QueryList","notifyOnChanges","_emitter","emit","SystemJsNgModuleLoaderConfig","SystemJsNgModuleLoader","loadAndCompile","path","loadFactory","factoryClassSuffix","FACTORY_CLASS_SUFFIX","exportName","System","import","_config","factoryPathPrefix","module","factoryPathSuffix","then","factory","checkNotEmpty","ModuleWithComponentFactories","ngModuleFactory","componentFactories","clearCacheFor","trace","events","CodegenComponentFactoryResolver","resolveComponentFactory","_factories","tslib_1.__extends","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_","_injector","__extends","ngZone","isDevMode","run","ngZoneInjector","ReflectiveInjector","resolveAndCreate","useValue","moduleRef","moduleFactory","exceptionHandler","ErrorHandler","_modules","onError","compilerOptions","_moduleDoBootstrap","_bootstrapComponents","f","bootstrap","ngDoBootstrap","_zone","_console","_exceptionHandler","_componentFactoryResolver","_initStatus","_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","ComponentFactoryBoundToModule","NgModuleRef","selectorOrNode","compRef","NULL","_unloadComponent","testability","_loadComponent","componentRef","scope","_tickScope","e","Injectable","Console","warn","message","deprecatedParameter","originalError","_findOriginalError","_findContext","_globalKeyRegistry","numberOfKeys","_allKeys","result","paramTypes","paramAnnotations","parameters","parentCtor","tsickleCtorParams","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","_parent","_constructionCounter","_instantiateProvider","_getMaxNumberOfObjects","objs","multiProvider","_instantiate","ResolvedReflectiveFactory$$1","deps","dep","_getByReflectiveDependency","addKey","_getByKey","visibility","_getByKeySelf","_getObjByKeyId","keyId","_getByKeyDefault","inj","SkipSelf","inj_","id","UNDEFINED","_done","runInitializers","asyncInitPromises","resolve","appInits","initResult","isPromise","_donePromise","ViewMetadata","templateUrl","Version","full","split","slice","extendStatics","setPrototypeOf","__proto__","d","b","p","hasOwnProperty","OpaqueToken","__window","window","_global","__global","__self","_symbolIterator","Reflect$1","ViewChild","makePropDecorator","data","assign","first","isViewQuery","descendants","Query","ChangeDetectionStrategy","OnPush","Default","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","outputs","isPrivateService","isComponent","tokenKey","componentProvider","handleEvent","eventName","event","nodeFlags","nodeCount","parentFlags","query","parentView","createView","root","renderer","parentNodeDef","outputCount","createViewNodes","renderHost","isComponentView","hostDef","asElementData","renderElement","nodeData","componentView","compViewDef","listenToElementOutputs","viewContainer","createTemplateData","createViewContainerData","createText","createProviderInstance","createPipeInstance","createDirectiveInstance","compView","initView","createPureExpression","checkAndUpdateView","markProjectedViewsForCheck","execEmbeddedViewsAction","CheckAndUpdate","execQueriesAction","callLifecycleHooksChildrenFirst","checkAndUpdateNodeInline","v0","v1","v2","v3","v4","v5","v6","v7","v8","v9","projectedView","projectedViews","i_1","changed","checkAndUpdateElementInline","checkAndUpdateTextInline","checkAndUpdateDirectiveInline","checkAndUpdateNodeDynamic","checkAndUpdateElementDynamic","checkAndUpdateTextDynamic","checkNoChangesNodeInline","bindLen","checkBindingNoChanges","checkNoChangesQuery","destroyView","Destroy","execComponentViewsAction","destroyViewNodes","asTextData","renderText","action","embeddedViews","callViewAction","viewState","execProjectedViewsAction","CheckNoChangesProjectedViews","CheckAndUpdateProjectedViews","queryFlags","staticDynamicQueryFlag","checkType","checkAndUpdateQuery","initServicesIfNeeded","services","createDebugServices","createProdServices","resolveDep","createDebugContext","dirtyParentQueries","createProdRootView","prodCheckAndUpdateNode","debugSetCurrentNode","debugCreateRootView","debugCreateEmbeddedView","debugCreateComponentView","debugCreateNgModuleRef","debugOverrideProvider","applyProviderOverridesToView","findElementIndicesWithOverwrittenProviders","elIndicesWithOverwrittenProviders","lastElementDef","applyProviderOverridesToElement","viewDef$$1","elIndex","override","providerOverrides","size","applyProviderOverrides","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","_pureExpressionDef","propertyNames","prop","checkAndUpdatePureExpressionInline","asPureExpressionData","pipe","transform","ngContentDef","appendNgContent","queryDef","bindingDefs","bindingType","queryIds","isEmbeddedView","tplDef","filterId","queryList","asQueryList","dirty","directiveInstance","newValues","elementDef_1","calcQueryValues","asProviderData","reset","notify","boundValue","startIndex","endIndex","valueType","elementData","k","embeddedView","dvc","declaredViewContainer","_projectedViews","getQueryValue","queryValueType","ElementRef","attachEmbeddedView","viewIndex","markNodeAsProjectedTemplate","detachEmbeddedView","removeFromArray","detachProjectedView","moveEmbeddedView","oldViewIndex","newViewIndex","prevRenderNode","arr","nodeValue","directiveDef","ctor","props","suffix","splitMatchedQueriesDsl","matchedQueriesDsl","depDefs","splitDepsDsl","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","templateFactory","bindingFlags","attrs","componentRendererType","elementDef","namespaceAndName","fixedAttrs","splitNamespace","_c","namespaceAndName_1","suffixOrSecurityContext","_d","ns_1","name_1","outputDefs","_e","resolveRendererType2","calcBindingFlags","createComment","parentEl","getParentRenderElement","appendChild","output","handleEventClosure","renderEventHandlerClosure","elementEventFullName","checkAndUpdateElementValue","renderNode$$1","setElementAttribute","setElementClass","setElementStyle","renderValue","sanitizer","sanitize","STYLE","unit","moduleDef","providersByKey","resolveNgModuleDep","InjectorRefTokenKey$1","NgModuleRefTokenKey","_createProviderInstance$1","_createClass","_callFactory","callNgModuleLifecycle","provDef","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","isListLikeIterableA","isListLikeIterable","isListLikeIterableB","areIterablesEqual","comparator","iterator1","getSymbolIterator","iterator2","noComponentFactoryError","detectWTF","createPlatform","createPlatformFactory","parentPlatformFactory","marker","extraProviders","platform","getPlatform","ALLOW_MULTIPLE_PLATFORMS","_callAndReportToErrorHandler","errorHandler","registerModuleFactory","_queryNodeChildren","predicate","matches","findFirstClosedCycle","res","injectionError","constructResolvingMessage","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","Inject","_createDependency","paramMetadata","Optional","Self","exports","require","Symbol","iterator","getOwnPropertyNames","overriddenName","applyParams","fnOrArray","String","Function","Number","annoLength","paramsAnnotations","annotation","extractAnnotation","Class","clsDef","proto","extends","Reflect","DecoratorFactory","objOrType","metaCtor","annotationInstance","chainAnnotation","TypeDecorator","cls","defineMetadata","chainFn","makeMetadataCtor","parentClass","ParamDecoratorFactory","ParamDecorator","unusedKey","PropDecoratorFactory","bind","meta","unshift","decoratorInstance"],"mappings":"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"}